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

Rev	Author	Line No.	Line
5217	serge	1	/* ieee.c -- Read and write IEEE-695 debugging information.
		2	Copyright 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007,
		3	2008, 2009, 2010, 2011 Free Software Foundation, Inc.
		4	Written by Ian Lance Taylor .
		5
		6	This file is part of GNU Binutils.
		7
		8	This program is free software; you can redistribute it and/or modify
		9	it under the terms of the GNU General Public License as published by
		10	the Free Software Foundation; either version 3 of the License, or
		11	(at your option) any later version.
		12
		13	This program is distributed in the hope that it will be useful,
		14	but WITHOUT ANY WARRANTY; without even the implied warranty of
		15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		16	GNU General Public License for more details.
		17
		18	You should have received a copy of the GNU General Public License
		19	along with this program; if not, write to the Free Software
		20	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
		21	02110-1301, USA. */
		22
		23	/* This file reads and writes IEEE-695 debugging information. */
		24
		25	#include "sysdep.h"
		26	#include
		27	#include "bfd.h"
		28	#include "ieee.h"
		29	#include "libiberty.h"
		30	#include "debug.h"
		31	#include "budbg.h"
		32	#include "filenames.h"
		33
		34	/* This structure holds an entry on the block stack. */
		35
		36	struct ieee_block
		37	{
		38	/* The kind of block. */
		39	int kind;
		40	/* The source file name, for a BB5 block. */
		41	const char *filename;
		42	/* The index of the function type, for a BB4 or BB6 block. */
		43	unsigned int fnindx;
		44	/* TRUE if this function is being skipped. */
		45	bfd_boolean skip;
		46	};
		47
		48	/* This structure is the block stack. */
		49
		50	#define BLOCKSTACK_SIZE (16)
		51
		52	struct ieee_blockstack
		53	{
		54	/* The stack pointer. */
		55	struct ieee_block *bsp;
		56	/* The stack. */
		57	struct ieee_block stack[BLOCKSTACK_SIZE];
		58	};
		59
		60	/* This structure holds information for a variable. */
		61
		62	enum ieee_var_kind
		63	{
		64	IEEE_UNKNOWN,
		65	IEEE_EXTERNAL,
		66	IEEE_GLOBAL,
		67	IEEE_STATIC,
		68	IEEE_LOCAL,
		69	IEEE_FUNCTION
		70	};
		71
		72	struct ieee_var
		73	{
		74	/* Start of name. */
		75	const char *name;
		76	/* Length of name. */
		77	unsigned long namlen;
		78	/* Type. */
		79	debug_type type;
		80	/* Slot if we make an indirect type. */
		81	debug_type *pslot;
		82	/* Kind of variable or function. */
		83	enum ieee_var_kind kind;
		84	};
		85
		86	/* This structure holds all the variables. */
		87
		88	struct ieee_vars
		89	{
		90	/* Number of slots allocated. */
		91	unsigned int alloc;
		92	/* Variables. */
		93	struct ieee_var *vars;
		94	};
		95
		96	/* This structure holds information for a type. We need this because
		97	we don't want to represent bitfields as real types. */
		98
		99	struct ieee_type
		100	{
		101	/* Type. */
		102	debug_type type;
		103	/* Slot if this is type is referenced before it is defined. */
		104	debug_type *pslot;
		105	/* Slots for arguments if we make indirect types for them. */
		106	debug_type *arg_slots;
		107	/* If this is a bitfield, this is the size in bits. If this is not
		108	a bitfield, this is zero. */
		109	unsigned long bitsize;
		110	};
		111
		112	/* This structure holds all the type information. */
		113
		114	struct ieee_types
		115	{
		116	/* Number of slots allocated. */
		117	unsigned int alloc;
		118	/* Types. */
		119	struct ieee_type *types;
		120	/* Builtin types. */
		121	#define BUILTIN_TYPE_COUNT (60)
		122	debug_type builtins[BUILTIN_TYPE_COUNT];
		123	};
		124
		125	/* This structure holds a linked last of structs with their tag names,
		126	so that we can convert them to C++ classes if necessary. */
		127
		128	struct ieee_tag
		129	{
		130	/* Next tag. */
		131	struct ieee_tag *next;
		132	/* This tag name. */
		133	const char *name;
		134	/* The type of the tag. */
		135	debug_type type;
		136	/* The tagged type is an indirect type pointing at this slot. */
		137	debug_type slot;
		138	/* This is an array of slots used when a field type is converted
		139	into a indirect type, in case it needs to be later converted into
		140	a reference type. */
		141	debug_type *fslots;
		142	};
		143
		144	/* This structure holds the information we pass around to the parsing
		145	functions. */
		146
		147	struct ieee_info
		148	{
		149	/* The debugging handle. */
		150	void *dhandle;
		151	/* The BFD. */
		152	bfd *abfd;
		153	/* The start of the bytes to be parsed. */
		154	const bfd_byte *bytes;
		155	/* The end of the bytes to be parsed. */
		156	const bfd_byte *pend;
		157	/* The block stack. */
		158	struct ieee_blockstack blockstack;
		159	/* Whether we have seen a BB1 or BB2. */
		160	bfd_boolean saw_filename;
		161	/* The variables. */
		162	struct ieee_vars vars;
		163	/* The global variables, after a global typedef block. */
		164	struct ieee_vars *global_vars;
		165	/* The types. */
		166	struct ieee_types types;
		167	/* The global types, after a global typedef block. */
		168	struct ieee_types *global_types;
		169	/* The list of tagged structs. */
		170	struct ieee_tag *tags;
		171	};
		172
		173	/* Basic builtin types, not including the pointers. */
		174
		175	enum builtin_types
		176	{
		177	builtin_unknown = 0,
		178	builtin_void = 1,
		179	builtin_signed_char = 2,
		180	builtin_unsigned_char = 3,
		181	builtin_signed_short_int = 4,
		182	builtin_unsigned_short_int = 5,
		183	builtin_signed_long = 6,
		184	builtin_unsigned_long = 7,
		185	builtin_signed_long_long = 8,
		186	builtin_unsigned_long_long = 9,
		187	builtin_float = 10,
		188	builtin_double = 11,
		189	builtin_long_double = 12,
		190	builtin_long_long_double = 13,
		191	builtin_quoted_string = 14,
		192	builtin_instruction_address = 15,
		193	builtin_int = 16,
		194	builtin_unsigned = 17,
		195	builtin_unsigned_int = 18,
		196	builtin_char = 19,
		197	builtin_long = 20,
		198	builtin_short = 21,
		199	builtin_unsigned_short = 22,
		200	builtin_short_int = 23,
		201	builtin_signed_short = 24,
		202	builtin_bcd_float = 25
		203	};
		204
		205	/* These are the values found in the derivation flags of a 'b'
		206	component record of a 'T' type extension record in a C++ pmisc
		207	record. These are bitmasks. */
		208
		209	/* Set for a private base class, clear for a public base class.
		210	Protected base classes are not supported. */
		211	#define BASEFLAGS_PRIVATE (0x1)
		212	/* Set for a virtual base class. */
		213	#define BASEFLAGS_VIRTUAL (0x2)
		214	/* Set for a friend class, clear for a base class. */
		215	#define BASEFLAGS_FRIEND (0x10)
		216
		217	/* These are the values found in the specs flags of a 'd', 'm', or 'v'
		218	component record of a 'T' type extension record in a C++ pmisc
		219	record. The same flags are used for a 'M' record in a C++ pmisc
		220	record. */
		221
		222	/* The lower two bits hold visibility information. */
		223	#define CXXFLAGS_VISIBILITY (0x3)
		224	/* This value in the lower two bits indicates a public member. */
		225	#define CXXFLAGS_VISIBILITY_PUBLIC (0x0)
		226	/* This value in the lower two bits indicates a private member. */
		227	#define CXXFLAGS_VISIBILITY_PRIVATE (0x1)
		228	/* This value in the lower two bits indicates a protected member. */
		229	#define CXXFLAGS_VISIBILITY_PROTECTED (0x2)
		230	/* Set for a static member. */
		231	#define CXXFLAGS_STATIC (0x4)
		232	/* Set for a virtual override. */
		233	#define CXXFLAGS_OVERRIDE (0x8)
		234	/* Set for a friend function. */
		235	#define CXXFLAGS_FRIEND (0x10)
		236	/* Set for a const function. */
		237	#define CXXFLAGS_CONST (0x20)
		238	/* Set for a volatile function. */
		239	#define CXXFLAGS_VOLATILE (0x40)
		240	/* Set for an overloaded function. */
		241	#define CXXFLAGS_OVERLOADED (0x80)
		242	/* Set for an operator function. */
		243	#define CXXFLAGS_OPERATOR (0x100)
		244	/* Set for a constructor or destructor. */
		245	#define CXXFLAGS_CTORDTOR (0x400)
		246	/* Set for a constructor. */
		247	#define CXXFLAGS_CTOR (0x200)
		248	/* Set for an inline function. */
		249	#define CXXFLAGS_INLINE (0x800)
		250
		251	/* Local functions. */
		252
		253	static void ieee_error (struct ieee_info , const bfd_byte , const char *);
		254	static void ieee_eof (struct ieee_info *);
		255	static char savestring (const char , unsigned long);
		256	static bfd_boolean ieee_read_number
		257	(struct ieee_info , const bfd_byte , bfd_vma );
		258	static bfd_boolean ieee_read_optional_number
		259	(struct ieee_info , const bfd_byte , bfd_vma , bfd_boolean *);
		260	static bfd_boolean ieee_read_id
		261	(struct ieee_info , const bfd_byte , const char , unsigned long );
		262	static bfd_boolean ieee_read_optional_id
		263	(struct ieee_info , const bfd_byte , const char , unsigned long ,
		264	bfd_boolean *);
		265	static bfd_boolean ieee_read_expression
		266	(struct ieee_info , const bfd_byte , bfd_vma );
		267	static debug_type ieee_builtin_type
		268	(struct ieee_info , const bfd_byte , unsigned int);
		269	static bfd_boolean ieee_alloc_type
		270	(struct ieee_info *, unsigned int, bfd_boolean);
		271	static bfd_boolean ieee_read_type_index
		272	(struct ieee_info , const bfd_byte , debug_type );
		273	static int ieee_regno_to_genreg (bfd *, int);
		274	static int ieee_genreg_to_regno (bfd *, int);
		275	static bfd_boolean parse_ieee_bb (struct ieee_info , const bfd_byte *);
		276	static bfd_boolean parse_ieee_be (struct ieee_info , const bfd_byte *);
		277	static bfd_boolean parse_ieee_nn (struct ieee_info , const bfd_byte *);
		278	static bfd_boolean parse_ieee_ty (struct ieee_info , const bfd_byte *);
		279	static bfd_boolean parse_ieee_atn (struct ieee_info , const bfd_byte *);
		280	static bfd_boolean ieee_read_cxx_misc
		281	(struct ieee_info , const bfd_byte *, unsigned long);
		282	static bfd_boolean ieee_read_cxx_class
		283	(struct ieee_info , const bfd_byte *, unsigned long);
		284	static bfd_boolean ieee_read_cxx_defaults
		285	(struct ieee_info , const bfd_byte *, unsigned long);
		286	static bfd_boolean ieee_read_reference
		287	(struct ieee_info , const bfd_byte *);
		288	static bfd_boolean ieee_require_asn
		289	(struct ieee_info , const bfd_byte , bfd_vma );
		290	static bfd_boolean ieee_require_atn65
		291	(struct ieee_info , const bfd_byte , const char , unsigned long );
		292
		293	/* Report an error in the IEEE debugging information. */
		294
		295	static void
		296	ieee_error (struct ieee_info info, const bfd_byte p, const char *s)
		297	{
		298	if (p != NULL)
		299	fprintf (stderr, "%s: 0x%lx: %s (0x%x)\n", bfd_get_filename (info->abfd),
		300	(unsigned long) (p - info->bytes), s, *p);
		301	else
		302	fprintf (stderr, "%s: %s\n", bfd_get_filename (info->abfd), s);
		303	}
		304
		305	/* Report an unexpected EOF in the IEEE debugging information. */
		306
		307	static void
		308	ieee_eof (struct ieee_info *info)
		309	{
		310	ieee_error (info, (const bfd_byte *) NULL,
		311	_("unexpected end of debugging information"));
		312	}
		313
		314	/* Save a string in memory. */
		315
		316	static char *
		317	savestring (const char *start, unsigned long len)
		318	{
		319	char *ret;
		320
		321	ret = (char *) xmalloc (len + 1);
		322	memcpy (ret, start, len);
		323	ret[len] = '\0';
		324	return ret;
		325	}
		326
		327	/* Read a number which must be present in an IEEE file. */
		328
		329	static bfd_boolean
		330	ieee_read_number (struct ieee_info info, const bfd_byte pp, bfd_vma pv)
		331	{
		332	return ieee_read_optional_number (info, pp, pv, (bfd_boolean *) NULL);
		333	}
		334
		335	/* Read a number in an IEEE file. If ppresent is not NULL, the number
		336	need not be there. */
		337
		338	static bfd_boolean
		339	ieee_read_optional_number (struct ieee_info info, const bfd_byte *pp,
		340	bfd_vma pv, bfd_boolean ppresent)
		341	{
		342	ieee_record_enum_type b;
		343
		344	if (*pp >= info->pend)
		345	{
		346	if (ppresent != NULL)
		347	{
		348	*ppresent = FALSE;
		349	return TRUE;
		350	}
		351	ieee_eof (info);
		352	return FALSE;
		353	}
		354
		355	b = (ieee_record_enum_type) **pp;
		356	++*pp;
		357
		358	if (b <= ieee_number_end_enum)
		359	{
		360	*pv = (bfd_vma) b;
		361	if (ppresent != NULL)
		362	*ppresent = TRUE;
		363	return TRUE;
		364	}
		365
		366	if (b >= ieee_number_repeat_start_enum && b <= ieee_number_repeat_end_enum)
		367	{
		368	unsigned int i;
		369
		370	i = (int) b - (int) ieee_number_repeat_start_enum;
		371	if (*pp + i - 1 >= info->pend)
		372	{
		373	ieee_eof (info);
		374	return FALSE;
		375	}
		376
		377	*pv = 0;
		378	for (; i > 0; i--)
		379	{
		380	*pv <<= 8;
		381	pv += *pp;
		382	++*pp;
		383	}
		384
		385	if (ppresent != NULL)
		386	*ppresent = TRUE;
		387
		388	return TRUE;
		389	}
		390
		391	if (ppresent != NULL)
		392	{
		393	--*pp;
		394	*ppresent = FALSE;
		395	return TRUE;
		396	}
		397
		398	ieee_error (info, *pp - 1, _("invalid number"));
		399	return FALSE;
		400	}
		401
		402	/* Read a required string from an IEEE file. */
		403
		404	static bfd_boolean
		405	ieee_read_id (struct ieee_info info, const bfd_byte *pp,
		406	const char *pname, unsigned long pnamlen)
		407	{
		408	return ieee_read_optional_id (info, pp, pname, pnamlen, (bfd_boolean *) NULL);
		409	}
		410
		411	/* Read a string from an IEEE file. If ppresent is not NULL, the
		412	string is optional. */
		413
		414	static bfd_boolean
		415	ieee_read_optional_id (struct ieee_info info, const bfd_byte *pp,
		416	const char *pname, unsigned long pnamlen,
		417	bfd_boolean *ppresent)
		418	{
		419	bfd_byte b;
		420	unsigned long len;
		421
		422	if (*pp >= info->pend)
		423	{
		424	ieee_eof (info);
		425	return FALSE;
		426	}
		427
		428	b = **pp;
		429	++*pp;
		430
		431	if (b <= 0x7f)
		432	len = b;
		433	else if ((ieee_record_enum_type) b == ieee_extension_length_1_enum)
		434	{
		435	len = **pp;
		436	++*pp;
		437	}
		438	else if ((ieee_record_enum_type) b == ieee_extension_length_2_enum)
		439	{
		440	len = (*pp << 8) + (pp)[1];
		441	*pp += 2;
		442	}
		443	else
		444	{
		445	if (ppresent != NULL)
		446	{
		447	--*pp;
		448	*ppresent = FALSE;
		449	return TRUE;
		450	}
		451	ieee_error (info, *pp - 1, _("invalid string length"));
		452	return FALSE;
		453	}
		454
		455	if ((unsigned long) (info->pend - *pp) < len)
		456	{
		457	ieee_eof (info);
		458	return FALSE;
		459	}
		460
		461	pname = (const char ) *pp;
		462	*pnamlen = len;
		463	*pp += len;
		464
		465	if (ppresent != NULL)
		466	*ppresent = TRUE;
		467
		468	return TRUE;
		469	}
		470
		471	/* Read an expression from an IEEE file. Since this code is only used
		472	to parse debugging information, I haven't bothered to write a full
		473	blown IEEE expression parser. I've only thrown in the things I've
		474	seen in debugging information. This can be easily extended if
		475	necessary. */
		476
		477	static bfd_boolean
		478	ieee_read_expression (struct ieee_info info, const bfd_byte *pp,
		479	bfd_vma *pv)
		480	{
		481	const bfd_byte *expr_start;
		482	#define EXPR_STACK_SIZE (10)
		483	bfd_vma expr_stack[EXPR_STACK_SIZE];
		484	bfd_vma *esp;
		485
		486	expr_start = *pp;
		487
		488	esp = expr_stack;
		489
		490	while (1)
		491	{
		492	const bfd_byte *start;
		493	bfd_vma val;
		494	bfd_boolean present;
		495	ieee_record_enum_type c;
		496
		497	start = *pp;
		498
		499	if (! ieee_read_optional_number (info, pp, &val, &present))
		500	return FALSE;
		501
		502	if (present)
		503	{
		504	if (esp - expr_stack >= EXPR_STACK_SIZE)
		505	{
		506	ieee_error (info, start, _("expression stack overflow"));
		507	return FALSE;
		508	}
		509	*esp++ = val;
		510	continue;
		511	}
		512
		513	c = (ieee_record_enum_type) **pp;
		514
		515	if (c >= ieee_module_beginning_enum)
		516	break;
		517
		518	++*pp;
		519
		520	if (c == ieee_comma)
		521	break;
		522
		523	switch (c)
		524	{
		525	default:
		526	ieee_error (info, start, _("unsupported IEEE expression operator"));
		527	break;
		528
		529	case ieee_variable_R_enum:
		530	{
		531	bfd_vma indx;
		532	asection *s;
		533
		534	if (! ieee_read_number (info, pp, &indx))
		535	return FALSE;
		536	for (s = info->abfd->sections; s != NULL; s = s->next)
		537	if ((bfd_vma) s->target_index == indx)
		538	break;
		539	if (s == NULL)
		540	{
		541	ieee_error (info, start, _("unknown section"));
		542	return FALSE;
		543	}
		544
		545	if (esp - expr_stack >= EXPR_STACK_SIZE)
		546	{
		547	ieee_error (info, start, _("expression stack overflow"));
		548	return FALSE;
		549	}
		550
		551	*esp++ = bfd_get_section_vma (info->abfd, s);
		552	}
		553	break;
		554
		555	case ieee_function_plus_enum:
		556	case ieee_function_minus_enum:
		557	{
		558	bfd_vma v1, v2;
		559
		560	if (esp - expr_stack < 2)
		561	{
		562	ieee_error (info, start, _("expression stack underflow"));
		563	return FALSE;
		564	}
		565
		566	v1 = *--esp;
		567	v2 = *--esp;
		568	*esp++ = v1 + v2;
		569	}
		570	break;
		571	}
		572	}
		573
		574	if (esp - 1 != expr_stack)
		575	{
		576	ieee_error (info, expr_start, _("expression stack mismatch"));
		577	return FALSE;
		578	}
		579
		580	pv = --esp;
		581
		582	return TRUE;
		583	}
		584
		585	/* Return an IEEE builtin type. */
		586
		587	static debug_type
		588	ieee_builtin_type (struct ieee_info info, const bfd_byte p,
		589	unsigned int indx)
		590	{
		591	void *dhandle;
		592	debug_type type;
		593	const char *name;
		594
		595	if (indx < BUILTIN_TYPE_COUNT
		596	&& info->types.builtins[indx] != DEBUG_TYPE_NULL)
		597	return info->types.builtins[indx];
		598
		599	dhandle = info->dhandle;
		600
		601	if (indx >= 32 && indx < 64)
		602	{
		603	type = debug_make_pointer_type (dhandle,
		604	ieee_builtin_type (info, p, indx - 32));
		605	assert (indx < BUILTIN_TYPE_COUNT);
		606	info->types.builtins[indx] = type;
		607	return type;
		608	}
		609
		610	switch ((enum builtin_types) indx)
		611	{
		612	default:
		613	ieee_error (info, p, _("unknown builtin type"));
		614	return NULL;
		615
		616	case builtin_unknown:
		617	type = debug_make_void_type (dhandle);
		618	name = NULL;
		619	break;
		620
		621	case builtin_void:
		622	type = debug_make_void_type (dhandle);
		623	name = "void";
		624	break;
		625
		626	case builtin_signed_char:
		627	type = debug_make_int_type (dhandle, 1, FALSE);
		628	name = "signed char";
		629	break;
		630
		631	case builtin_unsigned_char:
		632	type = debug_make_int_type (dhandle, 1, TRUE);
		633	name = "unsigned char";
		634	break;
		635
		636	case builtin_signed_short_int:
		637	type = debug_make_int_type (dhandle, 2, FALSE);
		638	name = "signed short int";
		639	break;
		640
		641	case builtin_unsigned_short_int:
		642	type = debug_make_int_type (dhandle, 2, TRUE);
		643	name = "unsigned short int";
		644	break;
		645
		646	case builtin_signed_long:
		647	type = debug_make_int_type (dhandle, 4, FALSE);
		648	name = "signed long";
		649	break;
		650
		651	case builtin_unsigned_long:
		652	type = debug_make_int_type (dhandle, 4, TRUE);
		653	name = "unsigned long";
		654	break;
		655
		656	case builtin_signed_long_long:
		657	type = debug_make_int_type (dhandle, 8, FALSE);
		658	name = "signed long long";
		659	break;
		660
		661	case builtin_unsigned_long_long:
		662	type = debug_make_int_type (dhandle, 8, TRUE);
		663	name = "unsigned long long";
		664	break;
		665
		666	case builtin_float:
		667	type = debug_make_float_type (dhandle, 4);
		668	name = "float";
		669	break;
		670
		671	case builtin_double:
		672	type = debug_make_float_type (dhandle, 8);
		673	name = "double";
		674	break;
		675
		676	case builtin_long_double:
		677	/* FIXME: The size for this type should depend upon the
		678	processor. */
		679	type = debug_make_float_type (dhandle, 12);
		680	name = "long double";
		681	break;
		682
		683	case builtin_long_long_double:
		684	type = debug_make_float_type (dhandle, 16);
		685	name = "long long double";
		686	break;
		687
		688	case builtin_quoted_string:
		689	type = debug_make_array_type (dhandle,
		690	ieee_builtin_type (info, p,
		691	((unsigned int)
		692	builtin_char)),
		693	ieee_builtin_type (info, p,
		694	((unsigned int)
		695	builtin_int)),
		696	0, -1, TRUE);
		697	name = "QUOTED STRING";
		698	break;
		699
		700	case builtin_instruction_address:
		701	/* FIXME: This should be a code address. */
		702	type = debug_make_int_type (dhandle, 4, TRUE);
		703	name = "instruction address";
		704	break;
		705
		706	case builtin_int:
		707	/* FIXME: The size for this type should depend upon the
		708	processor. */
		709	type = debug_make_int_type (dhandle, 4, FALSE);
		710	name = "int";
		711	break;
		712
		713	case builtin_unsigned:
		714	/* FIXME: The size for this type should depend upon the
		715	processor. */
		716	type = debug_make_int_type (dhandle, 4, TRUE);
		717	name = "unsigned";
		718	break;
		719
		720	case builtin_unsigned_int:
		721	/* FIXME: The size for this type should depend upon the
		722	processor. */
		723	type = debug_make_int_type (dhandle, 4, TRUE);
		724	name = "unsigned int";
		725	break;
		726
		727	case builtin_char:
		728	type = debug_make_int_type (dhandle, 1, FALSE);
		729	name = "char";
		730	break;
		731
		732	case builtin_long:
		733	type = debug_make_int_type (dhandle, 4, FALSE);
		734	name = "long";
		735	break;
		736
		737	case builtin_short:
		738	type = debug_make_int_type (dhandle, 2, FALSE);
		739	name = "short";
		740	break;
		741
		742	case builtin_unsigned_short:
		743	type = debug_make_int_type (dhandle, 2, TRUE);
		744	name = "unsigned short";
		745	break;
		746
		747	case builtin_short_int:
		748	type = debug_make_int_type (dhandle, 2, FALSE);
		749	name = "short int";
		750	break;
		751
		752	case builtin_signed_short:
		753	type = debug_make_int_type (dhandle, 2, FALSE);
		754	name = "signed short";
		755	break;
		756
		757	case builtin_bcd_float:
		758	ieee_error (info, p, _("BCD float type not supported"));
		759	return DEBUG_TYPE_NULL;
		760	}
		761
		762	if (name != NULL)
		763	type = debug_name_type (dhandle, name, type);
		764
		765	assert (indx < BUILTIN_TYPE_COUNT);
		766
		767	info->types.builtins[indx] = type;
		768
		769	return type;
		770	}
		771
		772	/* Allocate more space in the type table. If ref is TRUE, this is a
		773	reference to the type; if it is not already defined, we should set
		774	up an indirect type. */
		775
		776	static bfd_boolean
		777	ieee_alloc_type (struct ieee_info *info, unsigned int indx, bfd_boolean ref)
		778	{
		779	unsigned int nalloc;
		780	register struct ieee_type *t;
		781	struct ieee_type *tend;
		782
		783	if (indx >= info->types.alloc)
		784	{
		785	nalloc = info->types.alloc;
		786	if (nalloc == 0)
		787	nalloc = 4;
		788	while (indx >= nalloc)
		789	nalloc *= 2;
		790
		791	info->types.types = ((struct ieee_type *)
		792	xrealloc (info->types.types,
		793	nalloc * sizeof *info->types.types));
		794
		795	memset (info->types.types + info->types.alloc, 0,
		796	(nalloc - info->types.alloc) * sizeof *info->types.types);
		797
		798	tend = info->types.types + nalloc;
		799	for (t = info->types.types + info->types.alloc; t < tend; t++)
		800	t->type = DEBUG_TYPE_NULL;
		801
		802	info->types.alloc = nalloc;
		803	}
		804
		805	if (ref)
		806	{
		807	t = info->types.types + indx;
		808	if (t->type == NULL)
		809	{
		810	t->pslot = (debug_type ) xmalloc (sizeof t->pslot);
		811	*t->pslot = DEBUG_TYPE_NULL;
		812	t->type = debug_make_indirect_type (info->dhandle, t->pslot,
		813	(const char *) NULL);
		814	if (t->type == NULL)
		815	return FALSE;
		816	}
		817	}
		818
		819	return TRUE;
		820	}
		821
		822	/* Read a type index and return the corresponding type. */
		823
		824	static bfd_boolean
		825	ieee_read_type_index (struct ieee_info info, const bfd_byte *pp,
		826	debug_type *ptype)
		827	{
		828	const bfd_byte *start;
		829	bfd_vma indx;
		830
		831	start = *pp;
		832
		833	if (! ieee_read_number (info, pp, &indx))
		834	return FALSE;
		835
		836	if (indx < 256)
		837	{
		838	*ptype = ieee_builtin_type (info, start, indx);
		839	if (*ptype == NULL)
		840	return FALSE;
		841	return TRUE;
		842	}
		843
		844	indx -= 256;
		845	if (! ieee_alloc_type (info, indx, TRUE))
		846	return FALSE;
		847
		848	*ptype = info->types.types[indx].type;
		849
		850	return TRUE;
		851	}
		852
		853	/* Parse IEEE debugging information for a file. This is passed the
		854	bytes which compose the Debug Information Part of an IEEE file. */
		855
		856	bfd_boolean
		857	parse_ieee (void dhandle, bfd abfd, const bfd_byte *bytes, bfd_size_type len)
		858	{
		859	struct ieee_info info;
		860	unsigned int i;
		861	const bfd_byte p, pend;
		862
		863	info.dhandle = dhandle;
		864	info.abfd = abfd;
		865	info.bytes = bytes;
		866	info.pend = bytes + len;
		867	info.blockstack.bsp = info.blockstack.stack;
		868	info.saw_filename = FALSE;
		869	info.vars.alloc = 0;
		870	info.vars.vars = NULL;
		871	info.global_vars = NULL;
		872	info.types.alloc = 0;
		873	info.types.types = NULL;
		874	info.global_types = NULL;
		875	info.tags = NULL;
		876	for (i = 0; i < BUILTIN_TYPE_COUNT; i++)
		877	info.types.builtins[i] = DEBUG_TYPE_NULL;
		878
		879	p = bytes;
		880	pend = info.pend;
		881	while (p < pend)
		882	{
		883	const bfd_byte *record_start;
		884	ieee_record_enum_type c;
		885
		886	record_start = p;
		887
		888	c = (ieee_record_enum_type) *p++;
		889
		890	if (c == ieee_at_record_enum)
		891	c = (ieee_record_enum_type) (((unsigned int) c << 8) \| *p++);
		892
		893	if (c <= ieee_number_repeat_end_enum)
		894	{
		895	ieee_error (&info, record_start, _("unexpected number"));
		896	return FALSE;
		897	}
		898
		899	switch (c)
		900	{
		901	default:
		902	ieee_error (&info, record_start, _("unexpected record type"));
		903	return FALSE;
		904
		905	case ieee_bb_record_enum:
		906	if (! parse_ieee_bb (&info, &p))
		907	return FALSE;
		908	break;
		909
		910	case ieee_be_record_enum:
		911	if (! parse_ieee_be (&info, &p))
		912	return FALSE;
		913	break;
		914
		915	case ieee_nn_record:
		916	if (! parse_ieee_nn (&info, &p))
		917	return FALSE;
		918	break;
		919
		920	case ieee_ty_record_enum:
		921	if (! parse_ieee_ty (&info, &p))
		922	return FALSE;
		923	break;
		924
		925	case ieee_atn_record_enum:
		926	if (! parse_ieee_atn (&info, &p))
		927	return FALSE;
		928	break;
		929	}
		930	}
		931
		932	if (info.blockstack.bsp != info.blockstack.stack)
		933	{
		934	ieee_error (&info, (const bfd_byte *) NULL,
		935	_("blocks left on stack at end"));
		936	return FALSE;
		937	}
		938
		939	return TRUE;
		940	}
		941
		942	/* Handle an IEEE BB record. */
		943
		944	static bfd_boolean
		945	parse_ieee_bb (struct ieee_info info, const bfd_byte *pp)
		946	{
		947	const bfd_byte *block_start;
		948	bfd_byte b;
		949	bfd_vma size;
		950	const char *name;
		951	unsigned long namlen;
		952	char *namcopy = NULL;
		953	unsigned int fnindx;
		954	bfd_boolean skip;
		955
		956	block_start = *pp;
		957
		958	b = **pp;
		959	++*pp;
		960
		961	if (! ieee_read_number (info, pp, &size)
		962	\|\| ! ieee_read_id (info, pp, &name, &namlen))
		963	return FALSE;
		964
		965	fnindx = (unsigned int) -1;
		966	skip = FALSE;
		967
		968	switch (b)
		969	{
		970	case 1:
		971	/* BB1: Type definitions local to a module. */
		972	namcopy = savestring (name, namlen);
		973	if (namcopy == NULL)
		974	return FALSE;
		975	if (! debug_set_filename (info->dhandle, namcopy))
		976	return FALSE;
		977	info->saw_filename = TRUE;
		978
		979	/* Discard any variables or types we may have seen before. */
		980	if (info->vars.vars != NULL)
		981	free (info->vars.vars);
		982	info->vars.vars = NULL;
		983	info->vars.alloc = 0;
		984	if (info->types.types != NULL)
		985	free (info->types.types);
		986	info->types.types = NULL;
		987	info->types.alloc = 0;
		988
		989	/* Initialize the types to the global types. */
		990	if (info->global_types != NULL)
		991	{
		992	info->types.alloc = info->global_types->alloc;
		993	info->types.types = ((struct ieee_type *)
		994	xmalloc (info->types.alloc
		995	* sizeof (*info->types.types)));
		996	memcpy (info->types.types, info->global_types->types,
		997	info->types.alloc * sizeof (*info->types.types));
		998	}
		999
		1000	break;
		1001
		1002	case 2:
		1003	/* BB2: Global type definitions. The name is supposed to be
		1004	empty, but we don't check. */
		1005	if (! debug_set_filename (info->dhandle, "global"))
		1006	return FALSE;
		1007	info->saw_filename = TRUE;
		1008	break;
		1009
		1010	case 3:
		1011	/* BB3: High level module block begin. We don't have to do
		1012	anything here. The name is supposed to be the same as for
		1013	the BB1, but we don't check. */
		1014	break;
		1015
		1016	case 4:
		1017	/* BB4: Global function. */
		1018	{
		1019	bfd_vma stackspace, typindx, offset;
		1020	debug_type return_type;
		1021
		1022	if (! ieee_read_number (info, pp, &stackspace)
		1023	\|\| ! ieee_read_number (info, pp, &typindx)
		1024	\|\| ! ieee_read_expression (info, pp, &offset))
		1025	return FALSE;
		1026
		1027	/* We have no way to record the stack space. FIXME. */
		1028
		1029	if (typindx < 256)
		1030	{
		1031	return_type = ieee_builtin_type (info, block_start, typindx);
		1032	if (return_type == DEBUG_TYPE_NULL)
		1033	return FALSE;
		1034	}
		1035	else
		1036	{
		1037	typindx -= 256;
		1038	if (! ieee_alloc_type (info, typindx, TRUE))
		1039	return FALSE;
		1040	fnindx = typindx;
		1041	return_type = info->types.types[typindx].type;
		1042	if (debug_get_type_kind (info->dhandle, return_type)
		1043	== DEBUG_KIND_FUNCTION)
		1044	return_type = debug_get_return_type (info->dhandle,
		1045	return_type);
		1046	}
		1047
		1048	namcopy = savestring (name, namlen);
		1049	if (namcopy == NULL)
		1050	return FALSE;
		1051	if (! debug_record_function (info->dhandle, namcopy, return_type,
		1052	TRUE, offset))
		1053	return FALSE;
		1054	}
		1055	break;
		1056
		1057	case 5:
		1058	/* BB5: File name for source line numbers. */
		1059	{
		1060	unsigned int i;
		1061
		1062	/* We ignore the date and time. FIXME. */
		1063	for (i = 0; i < 6; i++)
		1064	{
		1065	bfd_vma ignore;
		1066	bfd_boolean present;
		1067
		1068	if (! ieee_read_optional_number (info, pp, &ignore, &present))
		1069	return FALSE;
		1070	if (! present)
		1071	break;
		1072	}
		1073
		1074	if (! info->saw_filename)
		1075	{
		1076	namcopy = savestring (name, namlen);
		1077	if (namcopy == NULL)
		1078	return FALSE;
		1079	if (! debug_set_filename (info->dhandle, namcopy))
		1080	return FALSE;
		1081	info->saw_filename = TRUE;
		1082	}
		1083
		1084	namcopy = savestring (name, namlen);
		1085	if (namcopy == NULL)
		1086	return FALSE;
		1087	if (! debug_start_source (info->dhandle, namcopy))
		1088	return FALSE;
		1089	}
		1090	break;
		1091
		1092	case 6:
		1093	/* BB6: Local function or block. */
		1094	{
		1095	bfd_vma stackspace, typindx, offset;
		1096
		1097	if (! ieee_read_number (info, pp, &stackspace)
		1098	\|\| ! ieee_read_number (info, pp, &typindx)
		1099	\|\| ! ieee_read_expression (info, pp, &offset))
		1100	return FALSE;
		1101
		1102	/* We have no way to record the stack space. FIXME. */
		1103
		1104	if (namlen == 0)
		1105	{
		1106	if (! debug_start_block (info->dhandle, offset))
		1107	return FALSE;
		1108	/* Change b to indicate that this is a block
		1109	rather than a function. */
		1110	b = 0x86;
		1111	}
		1112	else
		1113	{
		1114	/* The MRI C++ compiler will output a fake function named
		1115	__XRYCPP to hold C++ debugging information. We skip
		1116	that function. This is not crucial, but it makes
		1117	converting from IEEE to other debug formats work
		1118	better. */
		1119	if (strncmp (name, "__XRYCPP", namlen) == 0)
		1120	skip = TRUE;
		1121	else
		1122	{
		1123	debug_type return_type;
		1124
		1125	if (typindx < 256)
		1126	{
		1127	return_type = ieee_builtin_type (info, block_start,
		1128	typindx);
		1129	if (return_type == NULL)
		1130	return FALSE;
		1131	}
		1132	else
		1133	{
		1134	typindx -= 256;
		1135	if (! ieee_alloc_type (info, typindx, TRUE))
		1136	return FALSE;
		1137	fnindx = typindx;
		1138	return_type = info->types.types[typindx].type;
		1139	if (debug_get_type_kind (info->dhandle, return_type)
		1140	== DEBUG_KIND_FUNCTION)
		1141	return_type = debug_get_return_type (info->dhandle,
		1142	return_type);
		1143	}
		1144
		1145	namcopy = savestring (name, namlen);
		1146	if (namcopy == NULL)
		1147	return FALSE;
		1148	if (! debug_record_function (info->dhandle, namcopy,
		1149	return_type, FALSE, offset))
		1150	return FALSE;
		1151	}
		1152	}
		1153	}
		1154	break;
		1155
		1156	case 10:
		1157	/* BB10: Assembler module scope. In the normal case, we
		1158	completely ignore all this information. FIXME. */
		1159	{
		1160	const char inam, vstr;
		1161	unsigned long inamlen, vstrlen;
		1162	bfd_vma tool_type;
		1163	bfd_boolean present;
		1164	unsigned int i;
		1165
		1166	if (! info->saw_filename)
		1167	{
		1168	namcopy = savestring (name, namlen);
		1169	if (namcopy == NULL)
		1170	return FALSE;
		1171	if (! debug_set_filename (info->dhandle, namcopy))
		1172	return FALSE;
		1173	info->saw_filename = TRUE;
		1174	}
		1175
		1176	if (! ieee_read_id (info, pp, &inam, &inamlen)
		1177	\|\| ! ieee_read_number (info, pp, &tool_type)
		1178	\|\| ! ieee_read_optional_id (info, pp, &vstr, &vstrlen, &present))
		1179	return FALSE;
		1180	for (i = 0; i < 6; i++)
		1181	{
		1182	bfd_vma ignore;
		1183
		1184	if (! ieee_read_optional_number (info, pp, &ignore, &present))
		1185	return FALSE;
		1186	if (! present)
		1187	break;
		1188	}
		1189	}
		1190	break;
		1191
		1192	case 11:
		1193	/* BB11: Module section. We completely ignore all this
		1194	information. FIXME. */
		1195	{
		1196	bfd_vma sectype, secindx, offset, map;
		1197	bfd_boolean present;
		1198
		1199	if (! ieee_read_number (info, pp, §ype)
		1200	\|\| ! ieee_read_number (info, pp, &secindx)
		1201	\|\| ! ieee_read_expression (info, pp, &offset)
		1202	\|\| ! ieee_read_optional_number (info, pp, &map, &present))
		1203	return FALSE;
		1204	}
		1205	break;
		1206
		1207	default:
		1208	ieee_error (info, block_start, _("unknown BB type"));
		1209	return FALSE;
		1210	}
		1211
		1212
		1213	/* Push this block on the block stack. */
		1214
		1215	if (info->blockstack.bsp >= info->blockstack.stack + BLOCKSTACK_SIZE)
		1216	{
		1217	ieee_error (info, (const bfd_byte *) NULL, _("stack overflow"));
		1218	return FALSE;
		1219	}
		1220
		1221	info->blockstack.bsp->kind = b;
		1222	if (b == 5)
		1223	info->blockstack.bsp->filename = namcopy;
		1224	info->blockstack.bsp->fnindx = fnindx;
		1225	info->blockstack.bsp->skip = skip;
		1226	++info->blockstack.bsp;
		1227
		1228	return TRUE;
		1229	}
		1230
		1231	/* Handle an IEEE BE record. */
		1232
		1233	static bfd_boolean
		1234	parse_ieee_be (struct ieee_info info, const bfd_byte *pp)
		1235	{
		1236	bfd_vma offset;
		1237
		1238	if (info->blockstack.bsp <= info->blockstack.stack)
		1239	{
		1240	ieee_error (info, *pp, _("stack underflow"));
		1241	return FALSE;
		1242	}
		1243	--info->blockstack.bsp;
		1244
		1245	switch (info->blockstack.bsp->kind)
		1246	{
		1247	case 2:
		1248	/* When we end the global typedefs block, we copy out the
		1249	contents of info->vars. This is because the variable indices
		1250	may be reused in the local blocks. However, we need to
		1251	preserve them so that we can locate a function returning a
		1252	reference variable whose type is named in the global typedef
		1253	block. */
		1254	info->global_vars = ((struct ieee_vars *)
		1255	xmalloc (sizeof *info->global_vars));
		1256	info->global_vars->alloc = info->vars.alloc;
		1257	info->global_vars->vars = ((struct ieee_var *)
		1258	xmalloc (info->vars.alloc
		1259	* sizeof (*info->vars.vars)));
		1260	memcpy (info->global_vars->vars, info->vars.vars,
		1261	info->vars.alloc * sizeof (*info->vars.vars));
		1262
		1263	/* We also copy out the non builtin parts of info->types, since
		1264	the types are discarded when we start a new block. */
		1265	info->global_types = ((struct ieee_types *)
		1266	xmalloc (sizeof *info->global_types));
		1267	info->global_types->alloc = info->types.alloc;
		1268	info->global_types->types = ((struct ieee_type *)
		1269	xmalloc (info->types.alloc
		1270	* sizeof (*info->types.types)));
		1271	memcpy (info->global_types->types, info->types.types,
		1272	info->types.alloc * sizeof (*info->types.types));
		1273	memset (info->global_types->builtins, 0,
		1274	sizeof (info->global_types->builtins));
		1275
		1276	break;
		1277
		1278	case 4:
		1279	case 6:
		1280	if (! ieee_read_expression (info, pp, &offset))
		1281	return FALSE;
		1282	if (! info->blockstack.bsp->skip)
		1283	{
		1284	if (! debug_end_function (info->dhandle, offset + 1))
		1285	return FALSE;
		1286	}
		1287	break;
		1288
		1289	case 0x86:
		1290	/* This is BE6 when BB6 started a block rather than a local
		1291	function. */
		1292	if (! ieee_read_expression (info, pp, &offset))
		1293	return FALSE;
		1294	if (! debug_end_block (info->dhandle, offset + 1))
		1295	return FALSE;
		1296	break;
		1297
		1298	case 5:
		1299	/* When we end a BB5, we look up the stack for the last BB5, if
		1300	there is one, so that we can call debug_start_source. */
		1301	if (info->blockstack.bsp > info->blockstack.stack)
		1302	{
		1303	struct ieee_block *bl;
		1304
		1305	bl = info->blockstack.bsp;
		1306	do
		1307	{
		1308	--bl;
		1309	if (bl->kind == 5)
		1310	{
		1311	if (! debug_start_source (info->dhandle, bl->filename))
		1312	return FALSE;
		1313	break;
		1314	}
		1315	}
		1316	while (bl != info->blockstack.stack);
		1317	}
		1318	break;
		1319
		1320	case 11:
		1321	if (! ieee_read_expression (info, pp, &offset))
		1322	return FALSE;
		1323	/* We just ignore the module size. FIXME. */
		1324	break;
		1325
		1326	default:
		1327	/* Other block types do not have any trailing information. */
		1328	break;
		1329	}
		1330
		1331	return TRUE;
		1332	}
		1333
		1334	/* Parse an NN record. */
		1335
		1336	static bfd_boolean
		1337	parse_ieee_nn (struct ieee_info info, const bfd_byte *pp)
		1338	{
		1339	const bfd_byte *nn_start;
		1340	bfd_vma varindx;
		1341	const char *name;
		1342	unsigned long namlen;
		1343
		1344	nn_start = *pp;
		1345
		1346	if (! ieee_read_number (info, pp, &varindx)
		1347	\|\| ! ieee_read_id (info, pp, &name, &namlen))
		1348	return FALSE;
		1349
		1350	if (varindx < 32)
		1351	{
		1352	ieee_error (info, nn_start, _("illegal variable index"));
		1353	return FALSE;
		1354	}
		1355	varindx -= 32;
		1356
		1357	if (varindx >= info->vars.alloc)
		1358	{
		1359	unsigned int alloc;
		1360
		1361	alloc = info->vars.alloc;
		1362	if (alloc == 0)
		1363	alloc = 4;
		1364	while (varindx >= alloc)
		1365	alloc *= 2;
		1366	info->vars.vars = ((struct ieee_var *)
		1367	xrealloc (info->vars.vars,
		1368	alloc * sizeof *info->vars.vars));
		1369	memset (info->vars.vars + info->vars.alloc, 0,
		1370	(alloc - info->vars.alloc) * sizeof *info->vars.vars);
		1371	info->vars.alloc = alloc;
		1372	}
		1373
		1374	info->vars.vars[varindx].name = name;
		1375	info->vars.vars[varindx].namlen = namlen;
		1376
		1377	return TRUE;
		1378	}
		1379
		1380	/* Parse a TY record. */
		1381
		1382	static bfd_boolean
		1383	parse_ieee_ty (struct ieee_info info, const bfd_byte *pp)
		1384	{
		1385	const bfd_byte ty_start, ty_var_start, *ty_code_start;
		1386	bfd_vma typeindx, varindx, tc;
		1387	void *dhandle;
		1388	bfd_boolean tag, typdef;
		1389	debug_type *arg_slots;
		1390	unsigned long type_bitsize;
		1391	debug_type type;
		1392
		1393	ty_start = *pp;
		1394
		1395	if (! ieee_read_number (info, pp, &typeindx))
		1396	return FALSE;
		1397
		1398	if (typeindx < 256)
		1399	{
		1400	ieee_error (info, ty_start, _("illegal type index"));
		1401	return FALSE;
		1402	}
		1403
		1404	typeindx -= 256;
		1405	if (! ieee_alloc_type (info, typeindx, FALSE))
		1406	return FALSE;
		1407
		1408	if (**pp != 0xce)
		1409	{
		1410	ieee_error (info, *pp, _("unknown TY code"));
		1411	return FALSE;
		1412	}
		1413	++*pp;
		1414
		1415	ty_var_start = *pp;
		1416
		1417	if (! ieee_read_number (info, pp, &varindx))
		1418	return FALSE;
		1419
		1420	if (varindx < 32)
		1421	{
		1422	ieee_error (info, ty_var_start, _("illegal variable index"));
		1423	return FALSE;
		1424	}
		1425	varindx -= 32;
		1426
		1427	if (varindx >= info->vars.alloc \|\| info->vars.vars[varindx].name == NULL)
		1428	{
		1429	ieee_error (info, ty_var_start, _("undefined variable in TY"));
		1430	return FALSE;
		1431	}
		1432
		1433	ty_code_start = *pp;
		1434
		1435	if (! ieee_read_number (info, pp, &tc))
		1436	return FALSE;
		1437
		1438	dhandle = info->dhandle;
		1439
		1440	tag = FALSE;
		1441	typdef = FALSE;
		1442	arg_slots = NULL;
		1443	type_bitsize = 0;
		1444	switch (tc)
		1445	{
		1446	default:
		1447	ieee_error (info, ty_code_start, _("unknown TY code"));
		1448	return FALSE;
		1449
		1450	case '!':
		1451	/* Unknown type, with size. We treat it as int. FIXME. */
		1452	{
		1453	bfd_vma size;
		1454
		1455	if (! ieee_read_number (info, pp, &size))
		1456	return FALSE;
		1457	type = debug_make_int_type (dhandle, size, FALSE);
		1458	}
		1459	break;
		1460
		1461	case 'A': /* Array. */
		1462	case 'a': /* FORTRAN array in column/row order. FIXME: Not
		1463	distinguished from normal array. */
		1464	{
		1465	debug_type ele_type;
		1466	bfd_vma lower, upper;
		1467
		1468	if (! ieee_read_type_index (info, pp, &ele_type)
		1469	\|\| ! ieee_read_number (info, pp, &lower)
		1470	\|\| ! ieee_read_number (info, pp, &upper))
		1471	return FALSE;
		1472	type = debug_make_array_type (dhandle, ele_type,
		1473	ieee_builtin_type (info, ty_code_start,
		1474	((unsigned int)
		1475	builtin_int)),
		1476	(bfd_signed_vma) lower,
		1477	(bfd_signed_vma) upper,
		1478	FALSE);
		1479	}
		1480	break;
		1481
		1482	case 'E':
		1483	/* Simple enumeration. */
		1484	{
		1485	bfd_vma size;
		1486	unsigned int alloc;
		1487	const char **names;
		1488	unsigned int c;
		1489	bfd_signed_vma *vals;
		1490	unsigned int i;
		1491
		1492	if (! ieee_read_number (info, pp, &size))
		1493	return FALSE;
		1494	/* FIXME: we ignore the enumeration size. */
		1495
		1496	alloc = 10;
		1497	names = (const char *) xmalloc (alloc sizeof *names);
		1498	memset (names, 0, alloc * sizeof *names);
		1499	c = 0;
		1500	while (1)
		1501	{
		1502	const char *name;
		1503	unsigned long namlen;
		1504	bfd_boolean present;
		1505
		1506	if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
		1507	return FALSE;
		1508	if (! present)
		1509	break;
		1510
		1511	if (c + 1 >= alloc)
		1512	{
		1513	alloc += 10;
		1514	names = ((const char **)
		1515	xrealloc (names, alloc * sizeof *names));
		1516	}
		1517
		1518	names[c] = savestring (name, namlen);
		1519	if (names[c] == NULL)
		1520	return FALSE;
		1521	++c;
		1522	}
		1523
		1524	names[c] = NULL;
		1525
		1526	vals = (bfd_signed_vma ) xmalloc (c sizeof *vals);
		1527	for (i = 0; i < c; i++)
		1528	vals[i] = i;
		1529
		1530	type = debug_make_enum_type (dhandle, names, vals);
		1531	tag = TRUE;
		1532	}
		1533	break;
		1534
		1535	case 'G':
		1536	/* Struct with bit fields. */
		1537	{
		1538	bfd_vma size;
		1539	unsigned int alloc;
		1540	debug_field *fields;
		1541	unsigned int c;
		1542
		1543	if (! ieee_read_number (info, pp, &size))
		1544	return FALSE;
		1545
		1546	alloc = 10;
		1547	fields = (debug_field ) xmalloc (alloc sizeof *fields);
		1548	c = 0;
		1549	while (1)
		1550	{
		1551	const char *name;
		1552	unsigned long namlen;
		1553	bfd_boolean present;
		1554	debug_type ftype;
		1555	bfd_vma bitpos, bitsize;
		1556
		1557	if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
		1558	return FALSE;
		1559	if (! present)
		1560	break;
		1561	if (! ieee_read_type_index (info, pp, &ftype)
		1562	\|\| ! ieee_read_number (info, pp, &bitpos)
		1563	\|\| ! ieee_read_number (info, pp, &bitsize))
		1564	return FALSE;
		1565
		1566	if (c + 1 >= alloc)
		1567	{
		1568	alloc += 10;
		1569	fields = ((debug_field *)
		1570	xrealloc (fields, alloc * sizeof *fields));
		1571	}
		1572
		1573	fields[c] = debug_make_field (dhandle, savestring (name, namlen),
		1574	ftype, bitpos, bitsize,
		1575	DEBUG_VISIBILITY_PUBLIC);
		1576	if (fields[c] == NULL)
		1577	return FALSE;
		1578	++c;
		1579	}
		1580
		1581	fields[c] = NULL;
		1582
		1583	type = debug_make_struct_type (dhandle, TRUE, size, fields);
		1584	tag = TRUE;
		1585	}
		1586	break;
		1587
		1588	case 'N':
		1589	/* Enumeration. */
		1590	{
		1591	unsigned int alloc;
		1592	const char **names;
		1593	bfd_signed_vma *vals;
		1594	unsigned int c;
		1595
		1596	alloc = 10;
		1597	names = (const char *) xmalloc (alloc sizeof *names);
		1598	vals = (bfd_signed_vma ) xmalloc (alloc sizeof *names);
		1599	c = 0;
		1600	while (1)
		1601	{
		1602	const char *name;
		1603	unsigned long namlen;
		1604	bfd_boolean present;
		1605	bfd_vma val;
		1606
		1607	if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
		1608	return FALSE;
		1609	if (! present)
		1610	break;
		1611	if (! ieee_read_number (info, pp, &val))
		1612	return FALSE;
		1613
		1614	/* If the length of the name is zero, then the value is
		1615	actually the size of the enum. We ignore this
		1616	information. FIXME. */
		1617	if (namlen == 0)
		1618	continue;
		1619
		1620	if (c + 1 >= alloc)
		1621	{
		1622	alloc += 10;
		1623	names = ((const char **)
		1624	xrealloc (names, alloc * sizeof *names));
		1625	vals = ((bfd_signed_vma *)
		1626	xrealloc (vals, alloc * sizeof *vals));
		1627	}
		1628
		1629	names[c] = savestring (name, namlen);
		1630	if (names[c] == NULL)
		1631	return FALSE;
		1632	vals[c] = (bfd_signed_vma) val;
		1633	++c;
		1634	}
		1635
		1636	names[c] = NULL;
		1637
		1638	type = debug_make_enum_type (dhandle, names, vals);
		1639	tag = TRUE;
		1640	}
		1641	break;
		1642
		1643	case 'O': /* Small pointer. We don't distinguish small and large
		1644	pointers. FIXME. */
		1645	case 'P': /* Large pointer. */
		1646	{
		1647	debug_type t;
		1648
		1649	if (! ieee_read_type_index (info, pp, &t))
		1650	return FALSE;
		1651	type = debug_make_pointer_type (dhandle, t);
		1652	}
		1653	break;
		1654
		1655	case 'R':
		1656	/* Range. */
		1657	{
		1658	bfd_vma low, high, signedp, size;
		1659
		1660	if (! ieee_read_number (info, pp, &low)
		1661	\|\| ! ieee_read_number (info, pp, &high)
		1662	\|\| ! ieee_read_number (info, pp, &signedp)
		1663	\|\| ! ieee_read_number (info, pp, &size))
		1664	return FALSE;
		1665
		1666	type = debug_make_range_type (dhandle,
		1667	debug_make_int_type (dhandle, size,
		1668	! signedp),
		1669	(bfd_signed_vma) low,
		1670	(bfd_signed_vma) high);
		1671	}
		1672	break;
		1673
		1674	case 'S': /* Struct. */
		1675	case 'U': /* Union. */
		1676	{
		1677	bfd_vma size;
		1678	unsigned int alloc;
		1679	debug_field *fields;
		1680	unsigned int c;
		1681
		1682	if (! ieee_read_number (info, pp, &size))
		1683	return FALSE;
		1684
		1685	alloc = 10;
		1686	fields = (debug_field ) xmalloc (alloc sizeof *fields);
		1687	c = 0;
		1688	while (1)
		1689	{
		1690	const char *name;
		1691	unsigned long namlen;
		1692	bfd_boolean present;
		1693	bfd_vma tindx;
		1694	bfd_vma offset;
		1695	debug_type ftype;
		1696	bfd_vma bitsize;
		1697
		1698	if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
		1699	return FALSE;
		1700	if (! present)
		1701	break;
		1702	if (! ieee_read_number (info, pp, &tindx)
		1703	\|\| ! ieee_read_number (info, pp, &offset))
		1704	return FALSE;
		1705
		1706	if (tindx < 256)
		1707	{
		1708	ftype = ieee_builtin_type (info, ty_code_start, tindx);
		1709	bitsize = 0;
		1710	offset *= 8;
		1711	}
		1712	else
		1713	{
		1714	struct ieee_type *t;
		1715
		1716	tindx -= 256;
		1717	if (! ieee_alloc_type (info, tindx, TRUE))
		1718	return FALSE;
		1719	t = info->types.types + tindx;
		1720	ftype = t->type;
		1721	bitsize = t->bitsize;
		1722	if (bitsize == 0)
		1723	offset *= 8;
		1724	}
		1725
		1726	if (c + 1 >= alloc)
		1727	{
		1728	alloc += 10;
		1729	fields = ((debug_field *)
		1730	xrealloc (fields, alloc * sizeof *fields));
		1731	}
		1732
		1733	fields[c] = debug_make_field (dhandle, savestring (name, namlen),
		1734	ftype, offset, bitsize,
		1735	DEBUG_VISIBILITY_PUBLIC);
		1736	if (fields[c] == NULL)
		1737	return FALSE;
		1738	++c;
		1739	}
		1740
		1741	fields[c] = NULL;
		1742
		1743	type = debug_make_struct_type (dhandle, tc == 'S', size, fields);
		1744	tag = TRUE;
		1745	}
		1746	break;
		1747
		1748	case 'T':
		1749	/* Typedef. */
		1750	if (! ieee_read_type_index (info, pp, &type))
		1751	return FALSE;
		1752	typdef = TRUE;
		1753	break;
		1754
		1755	case 'X':
		1756	/* Procedure. FIXME: This is an extern declaration, which we
		1757	have no way of representing. */
		1758	{
		1759	bfd_vma attr;
		1760	debug_type rtype;
		1761	bfd_vma nargs;
		1762	bfd_boolean present;
		1763	struct ieee_var *pv;
		1764
		1765	/* FIXME: We ignore the attribute and the argument names. */
		1766
		1767	if (! ieee_read_number (info, pp, &attr)
		1768	\|\| ! ieee_read_type_index (info, pp, &rtype)
		1769	\|\| ! ieee_read_number (info, pp, &nargs))
		1770	return FALSE;
		1771	do
		1772	{
		1773	const char *name;
		1774	unsigned long namlen;
		1775
		1776	if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
		1777	return FALSE;
		1778	}
		1779	while (present);
		1780
		1781	pv = info->vars.vars + varindx;
		1782	pv->kind = IEEE_EXTERNAL;
		1783	if (pv->namlen > 0
		1784	&& debug_get_type_kind (dhandle, rtype) == DEBUG_KIND_POINTER)
		1785	{
		1786	/* Set up the return type as an indirect type pointing to
		1787	the variable slot, so that we can change it to a
		1788	reference later if appropriate. */
		1789	pv->pslot = (debug_type ) xmalloc (sizeof pv->pslot);
		1790	*pv->pslot = rtype;
		1791	rtype = debug_make_indirect_type (dhandle, pv->pslot,
		1792	(const char *) NULL);
		1793	}
		1794
		1795	type = debug_make_function_type (dhandle, rtype, (debug_type *) NULL,
		1796	FALSE);
		1797	}
		1798	break;
		1799
		1800	case 'V':
		1801	case 'v':
		1802	/* Void. This is not documented, but the MRI compiler emits it. */
		1803	type = debug_make_void_type (dhandle);
		1804	break;
		1805
		1806	case 'Z':
		1807	/* Array with 0 lower bound. */
		1808	{
		1809	debug_type etype;
		1810	bfd_vma high;
		1811
		1812	if (! ieee_read_type_index (info, pp, &etype)
		1813	\|\| ! ieee_read_number (info, pp, &high))
		1814	return FALSE;
		1815
		1816	type = debug_make_array_type (dhandle, etype,
		1817	ieee_builtin_type (info, ty_code_start,
		1818	((unsigned int)
		1819	builtin_int)),
		1820	0, (bfd_signed_vma) high, FALSE);
		1821	}
		1822	break;
		1823
		1824	case 'c': /* Complex. */
		1825	case 'd': /* Double complex. */
		1826	{
		1827	const char *name;
		1828	unsigned long namlen;
		1829
		1830	/* FIXME: I don't know what the name means. */
		1831
		1832	if (! ieee_read_id (info, pp, &name, &namlen))
		1833	return FALSE;
		1834
		1835	type = debug_make_complex_type (dhandle, tc == 'c' ? 4 : 8);
		1836	}
		1837	break;
		1838
		1839	case 'f':
		1840	/* Pascal file name. FIXME. */
		1841	ieee_error (info, ty_code_start, _("Pascal file name not supported"));
		1842	return FALSE;
		1843
		1844	case 'g':
		1845	/* Bitfield type. */
		1846	{
		1847	bfd_vma signedp, bitsize, dummy;
		1848	const bfd_byte *hold;
		1849	bfd_boolean present;
		1850
		1851	if (! ieee_read_number (info, pp, &signedp)
		1852	\|\| ! ieee_read_number (info, pp, &bitsize))
		1853	return FALSE;
		1854
		1855	/* I think the documentation says that there is a type index,
		1856	but some actual files do not have one. */
		1857	hold = *pp;
		1858	if (! ieee_read_optional_number (info, pp, &dummy, &present))
		1859	return FALSE;
		1860	if (! present)
		1861	{
		1862	/* FIXME: This is just a guess. */
		1863	type = debug_make_int_type (dhandle, 4,
		1864	signedp ? FALSE : TRUE);
		1865	}
		1866	else
		1867	{
		1868	*pp = hold;
		1869	if (! ieee_read_type_index (info, pp, &type))
		1870	return FALSE;
		1871	}
		1872	type_bitsize = bitsize;
		1873	}
		1874	break;
		1875
		1876	case 'n':
		1877	/* Qualifier. */
		1878	{
		1879	bfd_vma kind;
		1880	debug_type t;
		1881
		1882	if (! ieee_read_number (info, pp, &kind)
		1883	\|\| ! ieee_read_type_index (info, pp, &t))
		1884	return FALSE;
		1885
		1886	switch (kind)
		1887	{
		1888	default:
		1889	ieee_error (info, ty_start, _("unsupported qualifier"));
		1890	return FALSE;
		1891
		1892	case 1:
		1893	type = debug_make_const_type (dhandle, t);
		1894	break;
		1895
		1896	case 2:
		1897	type = debug_make_volatile_type (dhandle, t);
		1898	break;
		1899	}
		1900	}
		1901	break;
		1902
		1903	case 's':
		1904	/* Set. */
		1905	{
		1906	bfd_vma size;
		1907	debug_type etype;
		1908
		1909	if (! ieee_read_number (info, pp, &size)
		1910	\|\| ! ieee_read_type_index (info, pp, &etype))
		1911	return FALSE;
		1912
		1913	/* FIXME: We ignore the size. */
		1914
		1915	type = debug_make_set_type (dhandle, etype, FALSE);
		1916	}
		1917	break;
		1918
		1919	case 'x':
		1920	/* Procedure with compiler dependencies. */
		1921	{
		1922	struct ieee_var *pv;
		1923	bfd_vma attr, frame_type, push_mask, nargs, level, father;
		1924	debug_type rtype;
		1925	debug_type *arg_types;
		1926	bfd_boolean varargs;
		1927	bfd_boolean present;
		1928
		1929	/* FIXME: We ignore some of this information. */
		1930
		1931	pv = info->vars.vars + varindx;
		1932
		1933	if (! ieee_read_number (info, pp, &attr)
		1934	\|\| ! ieee_read_number (info, pp, &frame_type)
		1935	\|\| ! ieee_read_number (info, pp, &push_mask)
		1936	\|\| ! ieee_read_type_index (info, pp, &rtype)
		1937	\|\| ! ieee_read_number (info, pp, &nargs))
		1938	return FALSE;
		1939	if (nargs == (bfd_vma) -1)
		1940	{
		1941	arg_types = NULL;
		1942	varargs = FALSE;
		1943	}
		1944	else
		1945	{
		1946	unsigned int i;
		1947
		1948	arg_types = ((debug_type *)
		1949	xmalloc ((nargs + 1) * sizeof *arg_types));
		1950	for (i = 0; i < nargs; i++)
		1951	if (! ieee_read_type_index (info, pp, arg_types + i))
		1952	return FALSE;
		1953
		1954	/* If the last type is pointer to void, this is really a
		1955	varargs function. */
		1956	varargs = FALSE;
		1957	if (nargs > 0)
		1958	{
		1959	debug_type last;
		1960
		1961	last = arg_types[nargs - 1];
		1962	if (debug_get_type_kind (dhandle, last) == DEBUG_KIND_POINTER
		1963	&& (debug_get_type_kind (dhandle,
		1964	debug_get_target_type (dhandle,
		1965	last))
		1966	== DEBUG_KIND_VOID))
		1967	{
		1968	--nargs;
		1969	varargs = TRUE;
		1970	}
		1971	}
		1972
		1973	/* If there are any pointer arguments, turn them into
		1974	indirect types in case we later need to convert them to
		1975	reference types. */
		1976	for (i = 0; i < nargs; i++)
		1977	{
		1978	if (debug_get_type_kind (dhandle, arg_types[i])
		1979	== DEBUG_KIND_POINTER)
		1980	{
		1981	if (arg_slots == NULL)
		1982	{
		1983	arg_slots = ((debug_type *)
		1984	xmalloc (nargs * sizeof *arg_slots));
		1985	memset (arg_slots, 0, nargs * sizeof *arg_slots);
		1986	}
		1987	arg_slots[i] = arg_types[i];
		1988	arg_types[i] =
		1989	debug_make_indirect_type (dhandle,
		1990	arg_slots + i,
		1991	(const char *) NULL);
		1992	}
		1993	}
		1994
		1995	arg_types[nargs] = DEBUG_TYPE_NULL;
		1996	}
		1997	if (! ieee_read_number (info, pp, &level)
		1998	\|\| ! ieee_read_optional_number (info, pp, &father, &present))
		1999	return FALSE;
		2000
		2001	/* We can't distinguish between a global function and a static
		2002	function. */
		2003	pv->kind = IEEE_FUNCTION;
		2004
		2005	if (pv->namlen > 0
		2006	&& debug_get_type_kind (dhandle, rtype) == DEBUG_KIND_POINTER)
		2007	{
		2008	/* Set up the return type as an indirect type pointing to
		2009	the variable slot, so that we can change it to a
		2010	reference later if appropriate. */
		2011	pv->pslot = (debug_type ) xmalloc (sizeof pv->pslot);
		2012	*pv->pslot = rtype;
		2013	rtype = debug_make_indirect_type (dhandle, pv->pslot,
		2014	(const char *) NULL);
		2015	}
		2016
		2017	type = debug_make_function_type (dhandle, rtype, arg_types, varargs);
		2018	}
		2019	break;
		2020	}
		2021
		2022	/* Record the type in the table. */
		2023
		2024	if (type == DEBUG_TYPE_NULL)
		2025	return FALSE;
		2026
		2027	info->vars.vars[varindx].type = type;
		2028
		2029	if ((tag \|\| typdef)
		2030	&& info->vars.vars[varindx].namlen > 0)
		2031	{
		2032	const char *name;
		2033
		2034	name = savestring (info->vars.vars[varindx].name,
		2035	info->vars.vars[varindx].namlen);
		2036	if (typdef)
		2037	type = debug_name_type (dhandle, name, type);
		2038	else if (tc == 'E' \|\| tc == 'N')
		2039	type = debug_tag_type (dhandle, name, type);
		2040	else
		2041	{
		2042	struct ieee_tag *it;
		2043
		2044	/* We must allocate all struct tags as indirect types, so
		2045	that if we later see a definition of the tag as a C++
		2046	record we can update the indirect slot and automatically
		2047	change all the existing references. */
		2048	it = (struct ieee_tag ) xmalloc (sizeof it);
		2049	memset (it, 0, sizeof *it);
		2050	it->next = info->tags;
		2051	info->tags = it;
		2052	it->name = name;
		2053	it->slot = type;
		2054
		2055	type = debug_make_indirect_type (dhandle, &it->slot, name);
		2056	type = debug_tag_type (dhandle, name, type);
		2057
		2058	it->type = type;
		2059	}
		2060	if (type == NULL)
		2061	return FALSE;
		2062	}
		2063
		2064	info->types.types[typeindx].type = type;
		2065	info->types.types[typeindx].arg_slots = arg_slots;
		2066	info->types.types[typeindx].bitsize = type_bitsize;
		2067
		2068	/* We may have already allocated type as an indirect type pointing
		2069	to slot. It does no harm to replace the indirect type with the
		2070	real type. Filling in slot as well handles the indirect types
		2071	which are already hanging around. */
		2072	if (info->types.types[typeindx].pslot != NULL)
		2073	*info->types.types[typeindx].pslot = type;
		2074
		2075	return TRUE;
		2076	}
		2077
		2078	/* Parse an ATN record. */
		2079
		2080	static bfd_boolean
		2081	parse_ieee_atn (struct ieee_info info, const bfd_byte *pp)
		2082	{
		2083	const bfd_byte atn_start, atn_code_start;
		2084	bfd_vma varindx;
		2085	struct ieee_var *pvar;
		2086	debug_type type;
		2087	bfd_vma atn_code;
		2088	void *dhandle;
		2089	bfd_vma v, v2, v3, v4, v5;
		2090	const char *name;
		2091	unsigned long namlen;
		2092	char *namcopy;
		2093	bfd_boolean present;
		2094	int blocktype;
		2095
		2096	atn_start = *pp;
		2097
		2098	if (! ieee_read_number (info, pp, &varindx)
		2099	\|\| ! ieee_read_type_index (info, pp, &type))
		2100	return FALSE;
		2101
		2102	atn_code_start = *pp;
		2103
		2104	if (! ieee_read_number (info, pp, &atn_code))
		2105	return FALSE;
		2106
		2107	if (varindx == 0)
		2108	{
		2109	pvar = NULL;
		2110	name = "";
		2111	namlen = 0;
		2112	}
		2113	else if (varindx < 32)
		2114	{
		2115	/* The MRI compiler reportedly sometimes emits variable lifetime
		2116	information for a register. We just ignore it. */
		2117	if (atn_code == 9)
		2118	return ieee_read_number (info, pp, &v);
		2119
		2120	ieee_error (info, atn_start, _("illegal variable index"));
		2121	return FALSE;
		2122	}
		2123	else
		2124	{
		2125	varindx -= 32;
		2126	if (varindx >= info->vars.alloc
		2127	\|\| info->vars.vars[varindx].name == NULL)
		2128	{
		2129	/* The MRI compiler or linker sometimes omits the NN record
		2130	for a pmisc record. */
		2131	if (atn_code == 62)
		2132	{
		2133	if (varindx >= info->vars.alloc)
		2134	{
		2135	unsigned int alloc;
		2136
		2137	alloc = info->vars.alloc;
		2138	if (alloc == 0)
		2139	alloc = 4;
		2140	while (varindx >= alloc)
		2141	alloc *= 2;
		2142	info->vars.vars = ((struct ieee_var *)
		2143	xrealloc (info->vars.vars,
		2144	(alloc
		2145	* sizeof *info->vars.vars)));
		2146	memset (info->vars.vars + info->vars.alloc, 0,
		2147	((alloc - info->vars.alloc)
		2148	* sizeof *info->vars.vars));
		2149	info->vars.alloc = alloc;
		2150	}
		2151
		2152	pvar = info->vars.vars + varindx;
		2153	pvar->name = "";
		2154	pvar->namlen = 0;
		2155	}
		2156	else
		2157	{
		2158	ieee_error (info, atn_start, _("undefined variable in ATN"));
		2159	return FALSE;
		2160	}
		2161	}
		2162
		2163	pvar = info->vars.vars + varindx;
		2164
		2165	pvar->type = type;
		2166
		2167	name = pvar->name;
		2168	namlen = pvar->namlen;
		2169	}
		2170
		2171	dhandle = info->dhandle;
		2172
		2173	/* If we are going to call debug_record_variable with a pointer
		2174	type, change the type to an indirect type so that we can later
		2175	change it to a reference type if we encounter a C++ pmisc 'R'
		2176	record. */
		2177	if (pvar != NULL
		2178	&& type != DEBUG_TYPE_NULL
		2179	&& debug_get_type_kind (dhandle, type) == DEBUG_KIND_POINTER)
		2180	{
		2181	switch (atn_code)
		2182	{
		2183	case 1:
		2184	case 2:
		2185	case 3:
		2186	case 5:
		2187	case 8:
		2188	case 10:
		2189	pvar->pslot = (debug_type ) xmalloc (sizeof pvar->pslot);
		2190	*pvar->pslot = type;
		2191	type = debug_make_indirect_type (dhandle, pvar->pslot,
		2192	(const char *) NULL);
		2193	pvar->type = type;
		2194	break;
		2195	}
		2196	}
		2197
		2198	switch (atn_code)
		2199	{
		2200	default:
		2201	ieee_error (info, atn_code_start, _("unknown ATN type"));
		2202	return FALSE;
		2203
		2204	case 1:
		2205	/* Automatic variable. */
		2206	if (! ieee_read_number (info, pp, &v))
		2207	return FALSE;
		2208	namcopy = savestring (name, namlen);
		2209	if (type == NULL)
		2210	type = debug_make_void_type (dhandle);
		2211	if (pvar != NULL)
		2212	pvar->kind = IEEE_LOCAL;
		2213	return debug_record_variable (dhandle, namcopy, type, DEBUG_LOCAL, v);
		2214
		2215	case 2:
		2216	/* Register variable. */
		2217	if (! ieee_read_number (info, pp, &v))
		2218	return FALSE;
		2219	namcopy = savestring (name, namlen);
		2220	if (type == NULL)
		2221	type = debug_make_void_type (dhandle);
		2222	if (pvar != NULL)
		2223	pvar->kind = IEEE_LOCAL;
		2224	return debug_record_variable (dhandle, namcopy, type, DEBUG_REGISTER,
		2225	ieee_regno_to_genreg (info->abfd, v));
		2226
		2227	case 3:
		2228	/* Static variable. */
		2229	if (! ieee_require_asn (info, pp, &v))
		2230	return FALSE;
		2231	namcopy = savestring (name, namlen);
		2232	if (type == NULL)
		2233	type = debug_make_void_type (dhandle);
		2234	if (info->blockstack.bsp <= info->blockstack.stack)
		2235	blocktype = 0;
		2236	else
		2237	blocktype = info->blockstack.bsp[-1].kind;
		2238	if (pvar != NULL)
		2239	{
		2240	if (blocktype == 4 \|\| blocktype == 6)
		2241	pvar->kind = IEEE_LOCAL;
		2242	else
		2243	pvar->kind = IEEE_STATIC;
		2244	}
		2245	return debug_record_variable (dhandle, namcopy, type,
		2246	(blocktype == 4 \|\| blocktype == 6
		2247	? DEBUG_LOCAL_STATIC
		2248	: DEBUG_STATIC),
		2249	v);
		2250
		2251	case 4:
		2252	/* External function. We don't currently record these. FIXME. */
		2253	if (pvar != NULL)
		2254	pvar->kind = IEEE_EXTERNAL;
		2255	return TRUE;
		2256
		2257	case 5:
		2258	/* External variable. We don't currently record these. FIXME. */
		2259	if (pvar != NULL)
		2260	pvar->kind = IEEE_EXTERNAL;
		2261	return TRUE;
		2262
		2263	case 7:
		2264	if (! ieee_read_number (info, pp, &v)
		2265	\|\| ! ieee_read_number (info, pp, &v2)
		2266	\|\| ! ieee_read_optional_number (info, pp, &v3, &present))
		2267	return FALSE;
		2268	if (present)
		2269	{
		2270	if (! ieee_read_optional_number (info, pp, &v4, &present))
		2271	return FALSE;
		2272	}
		2273
		2274	/* We just ignore the two optional fields in v3 and v4, since
		2275	they are not defined. */
		2276
		2277	if (! ieee_require_asn (info, pp, &v3))
		2278	return FALSE;
		2279
		2280	/* We have no way to record the column number. FIXME. */
		2281
		2282	return debug_record_line (dhandle, v, v3);
		2283
		2284	case 8:
		2285	/* Global variable. */
		2286	if (! ieee_require_asn (info, pp, &v))
		2287	return FALSE;
		2288	namcopy = savestring (name, namlen);
		2289	if (type == NULL)
		2290	type = debug_make_void_type (dhandle);
		2291	if (pvar != NULL)
		2292	pvar->kind = IEEE_GLOBAL;
		2293	return debug_record_variable (dhandle, namcopy, type, DEBUG_GLOBAL, v);
		2294
		2295	case 9:
		2296	/* Variable lifetime information. */
		2297	if (! ieee_read_number (info, pp, &v))
		2298	return FALSE;
		2299
		2300	/* We have no way to record this information. FIXME. */
		2301	return TRUE;
		2302
		2303	case 10:
		2304	/* Locked register. The spec says that there are two required
		2305	fields, but at least on occasion the MRI compiler only emits
		2306	one. */
		2307	if (! ieee_read_number (info, pp, &v)
		2308	\|\| ! ieee_read_optional_number (info, pp, &v2, &present))
		2309	return FALSE;
		2310
		2311	/* I think this means a variable that is both in a register and
		2312	a frame slot. We ignore the frame slot. FIXME. */
		2313
		2314	namcopy = savestring (name, namlen);
		2315	if (type == NULL)
		2316	type = debug_make_void_type (dhandle);
		2317	if (pvar != NULL)
		2318	pvar->kind = IEEE_LOCAL;
		2319	return debug_record_variable (dhandle, namcopy, type, DEBUG_REGISTER, v);
		2320
		2321	case 11:
		2322	/* Reserved for FORTRAN common. */
		2323	ieee_error (info, atn_code_start, _("unsupported ATN11"));
		2324
		2325	/* Return TRUE to keep going. */
		2326	return TRUE;
		2327
		2328	case 12:
		2329	/* Based variable. */
		2330	v3 = 0;
		2331	v4 = 0x80;
		2332	v5 = 0;
		2333	if (! ieee_read_number (info, pp, &v)
		2334	\|\| ! ieee_read_number (info, pp, &v2)
		2335	\|\| ! ieee_read_optional_number (info, pp, &v3, &present))
		2336	return FALSE;
		2337	if (present)
		2338	{
		2339	if (! ieee_read_optional_number (info, pp, &v4, &present))
		2340	return FALSE;
		2341	if (present)
		2342	{
		2343	if (! ieee_read_optional_number (info, pp, &v5, &present))
		2344	return FALSE;
		2345	}
		2346	}
		2347
		2348	/* We have no way to record this information. FIXME. */
		2349
		2350	ieee_error (info, atn_code_start, _("unsupported ATN12"));
		2351
		2352	/* Return TRUE to keep going. */
		2353	return TRUE;
		2354
		2355	case 16:
		2356	/* Constant. The description of this that I have is ambiguous,
		2357	so I'm not going to try to implement it. */
		2358	if (! ieee_read_number (info, pp, &v)
		2359	\|\| ! ieee_read_optional_number (info, pp, &v2, &present))
		2360	return FALSE;
		2361	if (present)
		2362	{
		2363	if (! ieee_read_optional_number (info, pp, &v2, &present))
		2364	return FALSE;
		2365	if (present)
		2366	{
		2367	if (! ieee_read_optional_id (info, pp, &name, &namlen, &present))
		2368	return FALSE;
		2369	}
		2370	}
		2371
		2372	if ((ieee_record_enum_type) **pp == ieee_e2_first_byte_enum)
		2373	{
		2374	if (! ieee_require_asn (info, pp, &v3))
		2375	return FALSE;
		2376	}
		2377
		2378	return TRUE;
		2379
		2380	case 19:
		2381	/* Static variable from assembler. */
		2382	v2 = 0;
		2383	if (! ieee_read_number (info, pp, &v)
		2384	\|\| ! ieee_read_optional_number (info, pp, &v2, &present)
		2385	\|\| ! ieee_require_asn (info, pp, &v3))
		2386	return FALSE;
		2387	namcopy = savestring (name, namlen);
		2388	/* We don't really handle this correctly. FIXME. */
		2389	return debug_record_variable (dhandle, namcopy,
		2390	debug_make_void_type (dhandle),
		2391	v2 != 0 ? DEBUG_GLOBAL : DEBUG_STATIC,
		2392	v3);
		2393
		2394	case 62:
		2395	/* Procedure miscellaneous information. */
		2396	case 63:
		2397	/* Variable miscellaneous information. */
		2398	case 64:
		2399	/* Module miscellaneous information. */
		2400	if (! ieee_read_number (info, pp, &v)
		2401	\|\| ! ieee_read_number (info, pp, &v2)
		2402	\|\| ! ieee_read_optional_id (info, pp, &name, &namlen, &present))
		2403	return FALSE;
		2404
		2405	if (atn_code == 62 && v == 80)
		2406	{
		2407	if (present)
		2408	{
		2409	ieee_error (info, atn_code_start,
		2410	_("unexpected string in C++ misc"));
		2411	return FALSE;
		2412	}
		2413	return ieee_read_cxx_misc (info, pp, v2);
		2414	}
		2415
		2416	/* We just ignore all of this stuff. FIXME. */
		2417
		2418	for (; v2 > 0; --v2)
		2419	{
		2420	switch ((ieee_record_enum_type) **pp)
		2421	{
		2422	default:
		2423	ieee_error (info, *pp, _("bad misc record"));
		2424	return FALSE;
		2425
		2426	case ieee_at_record_enum:
		2427	if (! ieee_require_atn65 (info, pp, &name, &namlen))
		2428	return FALSE;
		2429	break;
		2430
		2431	case ieee_e2_first_byte_enum:
		2432	if (! ieee_require_asn (info, pp, &v3))
		2433	return FALSE;
		2434	break;
		2435	}
		2436	}
		2437
		2438	return TRUE;
		2439	}
		2440
		2441	/NOTREACHED/
		2442	}
		2443
		2444	/* Handle C++ debugging miscellaneous records. This is called for
		2445	procedure miscellaneous records of type 80. */
		2446
		2447	static bfd_boolean
		2448	ieee_read_cxx_misc (struct ieee_info info, const bfd_byte *pp,
		2449	unsigned long count)
		2450	{
		2451	const bfd_byte *start;
		2452	bfd_vma category;
		2453
		2454	start = *pp;
		2455
		2456	/* Get the category of C++ misc record. */
		2457	if (! ieee_require_asn (info, pp, &category))
		2458	return FALSE;
		2459	--count;
		2460
		2461	switch (category)
		2462	{
		2463	default:
		2464	ieee_error (info, start, _("unrecognized C++ misc record"));
		2465	return FALSE;
		2466
		2467	case 'T':
		2468	if (! ieee_read_cxx_class (info, pp, count))
		2469	return FALSE;
		2470	break;
		2471
		2472	case 'M':
		2473	{
		2474	bfd_vma flags;
		2475	const char *name;
		2476	unsigned long namlen;
		2477
		2478	/* The IEEE spec indicates that the 'M' record only has a
		2479	flags field. The MRI compiler also emits the name of the
		2480	function. */
		2481
		2482	if (! ieee_require_asn (info, pp, &flags))
		2483	return FALSE;
		2484	if (*pp < info->pend
		2485	&& (ieee_record_enum_type) **pp == ieee_at_record_enum)
		2486	{
		2487	if (! ieee_require_atn65 (info, pp, &name, &namlen))
		2488	return FALSE;
		2489	}
		2490
		2491	/* This is emitted for method functions, but I don't think we
		2492	care very much. It might help if it told us useful
		2493	information like the class with which this function is
		2494	associated, but it doesn't, so it isn't helpful. */
		2495	}
		2496	break;
		2497
		2498	case 'B':
		2499	if (! ieee_read_cxx_defaults (info, pp, count))
		2500	return FALSE;
		2501	break;
		2502
		2503	case 'z':
		2504	{
		2505	const char name, mangled, *cxx_class;
		2506	unsigned long namlen, mangledlen, classlen;
		2507	bfd_vma control;
		2508
		2509	/* Pointer to member. */
		2510
		2511	if (! ieee_require_atn65 (info, pp, &name, &namlen)
		2512	\|\| ! ieee_require_atn65 (info, pp, &mangled, &mangledlen)
		2513	\|\| ! ieee_require_atn65 (info, pp, &cxx_class, &classlen)
		2514	\|\| ! ieee_require_asn (info, pp, &control))
		2515	return FALSE;
		2516
		2517	/* FIXME: We should now track down name and change its type. */
		2518	}
		2519	break;
		2520
		2521	case 'R':
		2522	if (! ieee_read_reference (info, pp))
		2523	return FALSE;
		2524	break;
		2525	}
		2526
		2527	return TRUE;
		2528	}
		2529
		2530	/* Read a C++ class definition. This is a pmisc type 80 record of
		2531	category 'T'. */
		2532
		2533	static bfd_boolean
		2534	ieee_read_cxx_class (struct ieee_info info, const bfd_byte *pp,
		2535	unsigned long count)
		2536	{
		2537	const bfd_byte *start;
		2538	bfd_vma cxx_class;
		2539	const char *tag;
		2540	unsigned long taglen;
		2541	struct ieee_tag *it;
		2542	void *dhandle;
		2543	debug_field *fields;
		2544	unsigned int field_count, field_alloc;
		2545	debug_baseclass *baseclasses;
		2546	unsigned int baseclasses_count, baseclasses_alloc;
		2547	const debug_field *structfields;
		2548	struct ieee_method
		2549	{
		2550	const char *name;
		2551	unsigned long namlen;
		2552	debug_method_variant *variants;
		2553	unsigned count;
		2554	unsigned int alloc;
		2555	} *methods;
		2556	unsigned int methods_count, methods_alloc;
		2557	debug_type vptrbase;
		2558	bfd_boolean ownvptr;
		2559	debug_method *dmethods;
		2560
		2561	start = *pp;
		2562
		2563	if (! ieee_require_asn (info, pp, &cxx_class))
		2564	return FALSE;
		2565	--count;
		2566
		2567	if (! ieee_require_atn65 (info, pp, &tag, &taglen))
		2568	return FALSE;
		2569	--count;
		2570
		2571	/* Find the C struct with this name. */
		2572	for (it = info->tags; it != NULL; it = it->next)
		2573	if (it->name[0] == tag[0]
		2574	&& strncmp (it->name, tag, taglen) == 0
		2575	&& strlen (it->name) == taglen)
		2576	break;
		2577	if (it == NULL)
		2578	{
		2579	ieee_error (info, start, _("undefined C++ object"));
		2580	return FALSE;
		2581	}
		2582
		2583	dhandle = info->dhandle;
		2584
		2585	fields = NULL;
		2586	field_count = 0;
		2587	field_alloc = 0;
		2588	baseclasses = NULL;
		2589	baseclasses_count = 0;
		2590	baseclasses_alloc = 0;
		2591	methods = NULL;
		2592	methods_count = 0;
		2593	methods_alloc = 0;
		2594	vptrbase = DEBUG_TYPE_NULL;
		2595	ownvptr = FALSE;
		2596
		2597	structfields = debug_get_fields (dhandle, it->type);
		2598
		2599	while (count > 0)
		2600	{
		2601	bfd_vma id;
		2602	const bfd_byte *spec_start;
		2603
		2604	spec_start = *pp;
		2605
		2606	if (! ieee_require_asn (info, pp, &id))
		2607	return FALSE;
		2608	--count;
		2609
		2610	switch (id)
		2611	{
		2612	default:
		2613	ieee_error (info, spec_start, _("unrecognized C++ object spec"));
		2614	return FALSE;
		2615
		2616	case 'b':
		2617	{
		2618	bfd_vma flags, cinline;
		2619	const char base, fieldname;
		2620	unsigned long baselen, fieldlen;
		2621	char *basecopy;
		2622	debug_type basetype;
		2623	bfd_vma bitpos;
		2624	bfd_boolean virtualp;
		2625	enum debug_visibility visibility;
		2626	debug_baseclass baseclass;
		2627
		2628	/* This represents a base or friend class. */
		2629
		2630	if (! ieee_require_asn (info, pp, &flags)
		2631	\|\| ! ieee_require_atn65 (info, pp, &base, &baselen)
		2632	\|\| ! ieee_require_asn (info, pp, &cinline)
		2633	\|\| ! ieee_require_atn65 (info, pp, &fieldname, &fieldlen))
		2634	return FALSE;
		2635	count -= 4;
		2636
		2637	/* We have no way of recording friend information, so we
		2638	just ignore it. */
		2639	if ((flags & BASEFLAGS_FRIEND) != 0)
		2640	break;
		2641
		2642	/* I assume that either all of the members of the
		2643	baseclass are included in the object, starting at the
		2644	beginning of the object, or that none of them are
		2645	included. */
		2646
		2647	if ((fieldlen == 0) == (cinline == 0))
		2648	{
		2649	ieee_error (info, start, _("unsupported C++ object type"));
		2650	return FALSE;
		2651	}
		2652
		2653	basecopy = savestring (base, baselen);
		2654	basetype = debug_find_tagged_type (dhandle, basecopy,
		2655	DEBUG_KIND_ILLEGAL);
		2656	free (basecopy);
		2657	if (basetype == DEBUG_TYPE_NULL)
		2658	{
		2659	ieee_error (info, start, _("C++ base class not defined"));
		2660	return FALSE;
		2661	}
		2662
		2663	if (fieldlen == 0)
		2664	bitpos = 0;
		2665	else
		2666	{
		2667	const debug_field *pf;
		2668
		2669	if (structfields == NULL)
		2670	{
		2671	ieee_error (info, start, _("C++ object has no fields"));
		2672	return FALSE;
		2673	}
		2674
		2675	for (pf = structfields; *pf != DEBUG_FIELD_NULL; pf++)
		2676	{
		2677	const char *fname;
		2678
		2679	fname = debug_get_field_name (dhandle, *pf);
		2680	if (fname == NULL)
		2681	return FALSE;
		2682	if (fname[0] == fieldname[0]
		2683	&& strncmp (fname, fieldname, fieldlen) == 0
		2684	&& strlen (fname) == fieldlen)
		2685	break;
		2686	}
		2687	if (*pf == DEBUG_FIELD_NULL)
		2688	{
		2689	ieee_error (info, start,
		2690	_("C++ base class not found in container"));
		2691	return FALSE;
		2692	}
		2693
		2694	bitpos = debug_get_field_bitpos (dhandle, *pf);
		2695	}
		2696
		2697	if ((flags & BASEFLAGS_VIRTUAL) != 0)
		2698	virtualp = TRUE;
		2699	else
		2700	virtualp = FALSE;
		2701	if ((flags & BASEFLAGS_PRIVATE) != 0)
		2702	visibility = DEBUG_VISIBILITY_PRIVATE;
		2703	else
		2704	visibility = DEBUG_VISIBILITY_PUBLIC;
		2705
		2706	baseclass = debug_make_baseclass (dhandle, basetype, bitpos,
		2707	virtualp, visibility);
		2708	if (baseclass == DEBUG_BASECLASS_NULL)
		2709	return FALSE;
		2710
		2711	if (baseclasses_count + 1 >= baseclasses_alloc)
		2712	{
		2713	baseclasses_alloc += 10;
		2714	baseclasses = ((debug_baseclass *)
		2715	xrealloc (baseclasses,
		2716	(baseclasses_alloc
		2717	* sizeof *baseclasses)));
		2718	}
		2719
		2720	baseclasses[baseclasses_count] = baseclass;
		2721	++baseclasses_count;
		2722	baseclasses[baseclasses_count] = DEBUG_BASECLASS_NULL;
		2723	}
		2724	break;
		2725
		2726	case 'd':
		2727	{
		2728	bfd_vma flags;
		2729	const char fieldname, mangledname;
		2730	unsigned long fieldlen, mangledlen;
		2731	char *fieldcopy;
		2732	bfd_boolean staticp;
		2733	debug_type ftype;
		2734	const debug_field *pf = NULL;
		2735	enum debug_visibility visibility;
		2736	debug_field field;
		2737
		2738	/* This represents a data member. */
		2739
		2740	if (! ieee_require_asn (info, pp, &flags)
		2741	\|\| ! ieee_require_atn65 (info, pp, &fieldname, &fieldlen)
		2742	\|\| ! ieee_require_atn65 (info, pp, &mangledname, &mangledlen))
		2743	return FALSE;
		2744	count -= 3;
		2745
		2746	fieldcopy = savestring (fieldname, fieldlen);
		2747
		2748	staticp = (flags & CXXFLAGS_STATIC) != 0 ? TRUE : FALSE;
		2749
		2750	if (staticp)
		2751	{
		2752	struct ieee_var pv, pvend;
		2753
		2754	/* See if we can find a definition for this variable. */
		2755	pv = info->vars.vars;
		2756	pvend = pv + info->vars.alloc;
		2757	for (; pv < pvend; pv++)
		2758	if (pv->namlen == mangledlen
		2759	&& strncmp (pv->name, mangledname, mangledlen) == 0)
		2760	break;
		2761	if (pv < pvend)
		2762	ftype = pv->type;
		2763	else
		2764	{
		2765	/* This can happen if the variable is never used. */
		2766	ftype = ieee_builtin_type (info, start,
		2767	(unsigned int) builtin_void);
		2768	}
		2769	}
		2770	else
		2771	{
		2772	unsigned int findx;
		2773
		2774	if (structfields == NULL)
		2775	{
		2776	ieee_error (info, start, _("C++ object has no fields"));
		2777	return FALSE;
		2778	}
		2779
		2780	for (pf = structfields, findx = 0;
		2781	*pf != DEBUG_FIELD_NULL;
		2782	pf++, findx++)
		2783	{
		2784	const char *fname;
		2785
		2786	fname = debug_get_field_name (dhandle, *pf);
		2787	if (fname == NULL)
		2788	return FALSE;
		2789	if (fname[0] == mangledname[0]
		2790	&& strncmp (fname, mangledname, mangledlen) == 0
		2791	&& strlen (fname) == mangledlen)
		2792	break;
		2793	}
		2794	if (*pf == DEBUG_FIELD_NULL)
		2795	{
		2796	ieee_error (info, start,
		2797	_("C++ data member not found in container"));
		2798	return FALSE;
		2799	}
		2800
		2801	ftype = debug_get_field_type (dhandle, *pf);
		2802
		2803	if (debug_get_type_kind (dhandle, ftype) == DEBUG_KIND_POINTER)
		2804	{
		2805	/* We might need to convert this field into a
		2806	reference type later on, so make it an indirect
		2807	type. */
		2808	if (it->fslots == NULL)
		2809	{
		2810	unsigned int fcnt;
		2811	const debug_field *pfcnt;
		2812
		2813	fcnt = 0;
		2814	for (pfcnt = structfields;
		2815	*pfcnt != DEBUG_FIELD_NULL;
		2816	pfcnt++)
		2817	++fcnt;
		2818	it->fslots = ((debug_type *)
		2819	xmalloc (fcnt * sizeof *it->fslots));
		2820	memset (it->fslots, 0,
		2821	fcnt * sizeof *it->fslots);
		2822	}
		2823
		2824	if (ftype == DEBUG_TYPE_NULL)
		2825	return FALSE;
		2826	it->fslots[findx] = ftype;
		2827	ftype = debug_make_indirect_type (dhandle,
		2828	it->fslots + findx,
		2829	(const char *) NULL);
		2830	}
		2831	}
		2832	if (ftype == DEBUG_TYPE_NULL)
		2833	return FALSE;
		2834
		2835	switch (flags & CXXFLAGS_VISIBILITY)
		2836	{
		2837	default:
		2838	ieee_error (info, start, _("unknown C++ visibility"));
		2839	return FALSE;
		2840
		2841	case CXXFLAGS_VISIBILITY_PUBLIC:
		2842	visibility = DEBUG_VISIBILITY_PUBLIC;
		2843	break;
		2844
		2845	case CXXFLAGS_VISIBILITY_PRIVATE:
		2846	visibility = DEBUG_VISIBILITY_PRIVATE;
		2847	break;
		2848
		2849	case CXXFLAGS_VISIBILITY_PROTECTED:
		2850	visibility = DEBUG_VISIBILITY_PROTECTED;
		2851	break;
		2852	}
		2853
		2854	if (staticp)
		2855	{
		2856	char *mangledcopy;
		2857
		2858	mangledcopy = savestring (mangledname, mangledlen);
		2859
		2860	field = debug_make_static_member (dhandle, fieldcopy,
		2861	ftype, mangledcopy,
		2862	visibility);
		2863	}
		2864	else
		2865	{
		2866	bfd_vma bitpos, bitsize;
		2867
		2868	bitpos = debug_get_field_bitpos (dhandle, *pf);
		2869	bitsize = debug_get_field_bitsize (dhandle, *pf);
		2870	if (bitpos == (bfd_vma) -1 \|\| bitsize == (bfd_vma) -1)
		2871	{
		2872	ieee_error (info, start, _("bad C++ field bit pos or size"));
		2873	return FALSE;
		2874	}
		2875	field = debug_make_field (dhandle, fieldcopy, ftype, bitpos,
		2876	bitsize, visibility);
		2877	}
		2878
		2879	if (field == DEBUG_FIELD_NULL)
		2880	return FALSE;
		2881
		2882	if (field_count + 1 >= field_alloc)
		2883	{
		2884	field_alloc += 10;
		2885	fields = ((debug_field *)
		2886	xrealloc (fields, field_alloc * sizeof *fields));
		2887	}
		2888
		2889	fields[field_count] = field;
		2890	++field_count;
		2891	fields[field_count] = DEBUG_FIELD_NULL;
		2892	}
		2893	break;
		2894
		2895	case 'm':
		2896	case 'v':
		2897	{
		2898	bfd_vma flags, voffset, control;
		2899	const char name, mangled;
		2900	unsigned long namlen, mangledlen;
		2901	struct ieee_var pv, pvend;
		2902	debug_type type;
		2903	enum debug_visibility visibility;
		2904	bfd_boolean constp, volatilep;
		2905	char *mangledcopy;
		2906	debug_method_variant mv;
		2907	struct ieee_method *meth;
		2908	unsigned int im;
		2909
		2910	if (! ieee_require_asn (info, pp, &flags)
		2911	\|\| ! ieee_require_atn65 (info, pp, &name, &namlen)
		2912	\|\| ! ieee_require_atn65 (info, pp, &mangled, &mangledlen))
		2913	return FALSE;
		2914	count -= 3;
		2915	if (id != 'v')
		2916	voffset = 0;
		2917	else
		2918	{
		2919	if (! ieee_require_asn (info, pp, &voffset))
		2920	return FALSE;
		2921	--count;
		2922	}
		2923	if (! ieee_require_asn (info, pp, &control))
		2924	return FALSE;
		2925	--count;
		2926
		2927	/* We just ignore the control information. */
		2928
		2929	/* We have no way to represent friend information, so we
		2930	just ignore it. */
		2931	if ((flags & CXXFLAGS_FRIEND) != 0)
		2932	break;
		2933
		2934	/* We should already have seen a type for the function. */
		2935	pv = info->vars.vars;
		2936	pvend = pv + info->vars.alloc;
		2937	for (; pv < pvend; pv++)
		2938	if (pv->namlen == mangledlen
		2939	&& strncmp (pv->name, mangled, mangledlen) == 0)
		2940	break;
		2941
		2942	if (pv >= pvend)
		2943	{
		2944	/* We won't have type information for this function if
		2945	it is not included in this file. We don't try to
		2946	handle this case. FIXME. */
		2947	type = (debug_make_function_type
		2948	(dhandle,
		2949	ieee_builtin_type (info, start,
		2950	(unsigned int) builtin_void),
		2951	(debug_type *) NULL,
		2952	FALSE));
		2953	}
		2954	else
		2955	{
		2956	debug_type return_type;
		2957	const debug_type *arg_types;
		2958	bfd_boolean varargs;
		2959
		2960	if (debug_get_type_kind (dhandle, pv->type)
		2961	!= DEBUG_KIND_FUNCTION)
		2962	{
		2963	ieee_error (info, start,
		2964	_("bad type for C++ method function"));
		2965	return FALSE;
		2966	}
		2967
		2968	return_type = debug_get_return_type (dhandle, pv->type);
		2969	arg_types = debug_get_parameter_types (dhandle, pv->type,
		2970	&varargs);
		2971	if (return_type == DEBUG_TYPE_NULL \|\| arg_types == NULL)
		2972	{
		2973	ieee_error (info, start,
		2974	_("no type information for C++ method function"));
		2975	return FALSE;
		2976	}
		2977
		2978	type = debug_make_method_type (dhandle, return_type, it->type,
		2979	(debug_type *) arg_types,
		2980	varargs);
		2981	}
		2982	if (type == DEBUG_TYPE_NULL)
		2983	return FALSE;
		2984
		2985	switch (flags & CXXFLAGS_VISIBILITY)
		2986	{
		2987	default:
		2988	ieee_error (info, start, _("unknown C++ visibility"));
		2989	return FALSE;
		2990
		2991	case CXXFLAGS_VISIBILITY_PUBLIC:
		2992	visibility = DEBUG_VISIBILITY_PUBLIC;
		2993	break;
		2994
		2995	case CXXFLAGS_VISIBILITY_PRIVATE:
		2996	visibility = DEBUG_VISIBILITY_PRIVATE;
		2997	break;
		2998
		2999	case CXXFLAGS_VISIBILITY_PROTECTED:
		3000	visibility = DEBUG_VISIBILITY_PROTECTED;
		3001	break;
		3002	}
		3003
		3004	constp = (flags & CXXFLAGS_CONST) != 0 ? TRUE : FALSE;
		3005	volatilep = (flags & CXXFLAGS_VOLATILE) != 0 ? TRUE : FALSE;
		3006
		3007	mangledcopy = savestring (mangled, mangledlen);
		3008
		3009	if ((flags & CXXFLAGS_STATIC) != 0)
		3010	{
		3011	if (id == 'v')
		3012	{
		3013	ieee_error (info, start, _("C++ static virtual method"));
		3014	return FALSE;
		3015	}
		3016	mv = debug_make_static_method_variant (dhandle, mangledcopy,
		3017	type, visibility,
		3018	constp, volatilep);
		3019	}
		3020	else
		3021	{
		3022	debug_type vcontext;
		3023
		3024	if (id != 'v')
		3025	vcontext = DEBUG_TYPE_NULL;
		3026	else
		3027	{
		3028	/* FIXME: How can we calculate this correctly? */
		3029	vcontext = it->type;
		3030	}
		3031	mv = debug_make_method_variant (dhandle, mangledcopy, type,
		3032	visibility, constp,
		3033	volatilep, voffset,
		3034	vcontext);
		3035	}
		3036	if (mv == DEBUG_METHOD_VARIANT_NULL)
		3037	return FALSE;
		3038
		3039	for (meth = methods, im = 0; im < methods_count; meth++, im++)
		3040	if (meth->namlen == namlen
		3041	&& strncmp (meth->name, name, namlen) == 0)
		3042	break;
		3043	if (im >= methods_count)
		3044	{
		3045	if (methods_count >= methods_alloc)
		3046	{
		3047	methods_alloc += 10;
		3048	methods = ((struct ieee_method *)
		3049	xrealloc (methods,
		3050	methods_alloc * sizeof *methods));
		3051	}
		3052	methods[methods_count].name = name;
		3053	methods[methods_count].namlen = namlen;
		3054	methods[methods_count].variants = NULL;
		3055	methods[methods_count].count = 0;
		3056	methods[methods_count].alloc = 0;
		3057	meth = methods + methods_count;
		3058	++methods_count;
		3059	}
		3060
		3061	if (meth->count + 1 >= meth->alloc)
		3062	{
		3063	meth->alloc += 10;
		3064	meth->variants = ((debug_method_variant *)
		3065	xrealloc (meth->variants,
		3066	(meth->alloc
		3067	* sizeof *meth->variants)));
		3068	}
		3069
		3070	meth->variants[meth->count] = mv;
		3071	++meth->count;
		3072	meth->variants[meth->count] = DEBUG_METHOD_VARIANT_NULL;
		3073	}
		3074	break;
		3075
		3076	case 'o':
		3077	{
		3078	bfd_vma spec;
		3079
		3080	/* We have no way to store this information, so we just
		3081	ignore it. */
		3082	if (! ieee_require_asn (info, pp, &spec))
		3083	return FALSE;
		3084	--count;
		3085	if ((spec & 4) != 0)
		3086	{
		3087	const char *filename;
		3088	unsigned long filenamlen;
		3089	bfd_vma lineno;
		3090
		3091	if (! ieee_require_atn65 (info, pp, &filename, &filenamlen)
		3092	\|\| ! ieee_require_asn (info, pp, &lineno))
		3093	return FALSE;
		3094	count -= 2;
		3095	}
		3096	else if ((spec & 8) != 0)
		3097	{
		3098	const char *mangled;
		3099	unsigned long mangledlen;
		3100
		3101	if (! ieee_require_atn65 (info, pp, &mangled, &mangledlen))
		3102	return FALSE;
		3103	--count;
		3104	}
		3105	else
		3106	{
		3107	ieee_error (info, start,
		3108	_("unrecognized C++ object overhead spec"));
		3109	return FALSE;
		3110	}
		3111	}
		3112	break;
		3113
		3114	case 'z':
		3115	{
		3116	const char vname, base;
		3117	unsigned long vnamelen, baselen;
		3118	bfd_vma vsize, control;
		3119
		3120	/* A virtual table pointer. */
		3121
		3122	if (! ieee_require_atn65 (info, pp, &vname, &vnamelen)
		3123	\|\| ! ieee_require_asn (info, pp, &vsize)
		3124	\|\| ! ieee_require_atn65 (info, pp, &base, &baselen)
		3125	\|\| ! ieee_require_asn (info, pp, &control))
		3126	return FALSE;
		3127	count -= 4;
		3128
		3129	/* We just ignore the control number. We don't care what
		3130	the virtual table name is. We have no way to store the
		3131	virtual table size, and I don't think we care anyhow. */
		3132
		3133	/* FIXME: We can't handle multiple virtual table pointers. */
		3134
		3135	if (baselen == 0)
		3136	ownvptr = TRUE;
		3137	else
		3138	{
		3139	char *basecopy;
		3140
		3141	basecopy = savestring (base, baselen);
		3142	vptrbase = debug_find_tagged_type (dhandle, basecopy,
		3143	DEBUG_KIND_ILLEGAL);
		3144	free (basecopy);
		3145	if (vptrbase == DEBUG_TYPE_NULL)
		3146	{
		3147	ieee_error (info, start, _("undefined C++ vtable"));
		3148	return FALSE;
		3149	}
		3150	}
		3151	}
		3152	break;
		3153	}
		3154	}
		3155
		3156	/* Now that we have seen all the method variants, we can call
		3157	debug_make_method for each one. */
		3158
		3159	if (methods_count == 0)
		3160	dmethods = NULL;
		3161	else
		3162	{
		3163	unsigned int i;
		3164
		3165	dmethods = ((debug_method *)
		3166	xmalloc ((methods_count + 1) * sizeof *dmethods));
		3167	for (i = 0; i < methods_count; i++)
		3168	{
		3169	char *namcopy;
		3170
		3171	namcopy = savestring (methods[i].name, methods[i].namlen);
		3172	dmethods[i] = debug_make_method (dhandle, namcopy,
		3173	methods[i].variants);
		3174	if (dmethods[i] == DEBUG_METHOD_NULL)
		3175	return FALSE;
		3176	}
		3177	dmethods[i] = DEBUG_METHOD_NULL;
		3178	free (methods);
		3179	}
		3180
		3181	/* The struct type was created as an indirect type pointing at
		3182	it->slot. We update it->slot to automatically update all
		3183	references to this struct. */
		3184	it->slot = debug_make_object_type (dhandle,
		3185	cxx_class != 'u',
		3186	debug_get_type_size (dhandle,
		3187	it->slot),
		3188	fields, baseclasses, dmethods,
		3189	vptrbase, ownvptr);
		3190	if (it->slot == DEBUG_TYPE_NULL)
		3191	return FALSE;
		3192
		3193	return TRUE;
		3194	}
		3195
		3196	/* Read C++ default argument value and reference type information. */
		3197
		3198	static bfd_boolean
		3199	ieee_read_cxx_defaults (struct ieee_info info, const bfd_byte *pp,
		3200	unsigned long count)
		3201	{
		3202	const bfd_byte *start;
		3203	const char *fnname;
		3204	unsigned long fnlen;
		3205	bfd_vma defcount;
		3206
		3207	start = *pp;
		3208
		3209	/* Giving the function name before the argument count is an addendum
		3210	to the spec. The function name is demangled, though, so this
		3211	record must always refer to the current function. */
		3212
		3213	if (info->blockstack.bsp <= info->blockstack.stack
		3214	\|\| info->blockstack.bsp[-1].fnindx == (unsigned int) -1)
		3215	{
		3216	ieee_error (info, start, _("C++ default values not in a function"));
		3217	return FALSE;
		3218	}
		3219
		3220	if (! ieee_require_atn65 (info, pp, &fnname, &fnlen)
		3221	\|\| ! ieee_require_asn (info, pp, &defcount))
		3222	return FALSE;
		3223	count -= 2;
		3224
		3225	while (defcount-- > 0)
		3226	{
		3227	bfd_vma type, val;
		3228	const char *strval;
		3229	unsigned long strvallen;
		3230
		3231	if (! ieee_require_asn (info, pp, &type))
		3232	return FALSE;
		3233	--count;
		3234
		3235	switch (type)
		3236	{
		3237	case 0:
		3238	case 4:
		3239	break;
		3240
		3241	case 1:
		3242	case 2:
		3243	if (! ieee_require_asn (info, pp, &val))
		3244	return FALSE;
		3245	--count;
		3246	break;
		3247
		3248	case 3:
		3249	case 7:
		3250	if (! ieee_require_atn65 (info, pp, &strval, &strvallen))
		3251	return FALSE;
		3252	--count;
		3253	break;
		3254
		3255	default:
		3256	ieee_error (info, start, _("unrecognized C++ default type"));
		3257	return FALSE;
		3258	}
		3259
		3260	/* We have no way to record the default argument values, so we
		3261	just ignore them. FIXME. */
		3262	}
		3263
		3264	/* Any remaining arguments are indices of parameters that are really
		3265	reference type. */
		3266	if (count > 0)
		3267	{
		3268	void *dhandle;
		3269	debug_type *arg_slots;
		3270
		3271	dhandle = info->dhandle;
		3272	arg_slots = info->types.types[info->blockstack.bsp[-1].fnindx].arg_slots;
		3273	while (count-- > 0)
		3274	{
		3275	bfd_vma indx;
		3276	debug_type target;
		3277
		3278	if (! ieee_require_asn (info, pp, &indx))
		3279	return FALSE;
		3280	/* The index is 1 based. */
		3281	--indx;
		3282	if (arg_slots == NULL
		3283	\|\| arg_slots[indx] == DEBUG_TYPE_NULL
		3284	\|\| (debug_get_type_kind (dhandle, arg_slots[indx])
		3285	!= DEBUG_KIND_POINTER))
		3286	{
		3287	ieee_error (info, start, _("reference parameter is not a pointer"));
		3288	return FALSE;
		3289	}
		3290
		3291	target = debug_get_target_type (dhandle, arg_slots[indx]);
		3292	arg_slots[indx] = debug_make_reference_type (dhandle, target);
		3293	if (arg_slots[indx] == DEBUG_TYPE_NULL)
		3294	return FALSE;
		3295	}
		3296	}
		3297
		3298	return TRUE;
		3299	}
		3300
		3301	/* Read a C++ reference definition. */
		3302
		3303	static bfd_boolean
		3304	ieee_read_reference (struct ieee_info info, const bfd_byte *pp)
		3305	{
		3306	const bfd_byte *start;
		3307	bfd_vma flags;
		3308	const char cxx_class, name;
		3309	unsigned long classlen, namlen;
		3310	debug_type *pslot;
		3311	debug_type target;
		3312
		3313	start = *pp;
		3314
		3315	if (! ieee_require_asn (info, pp, &flags))
		3316	return FALSE;
		3317
		3318	/* Giving the class name before the member name is in an addendum to
		3319	the spec. */
		3320	if (flags == 3)
		3321	{
		3322	if (! ieee_require_atn65 (info, pp, &cxx_class, &classlen))
		3323	return FALSE;
		3324	}
		3325
		3326	if (! ieee_require_atn65 (info, pp, &name, &namlen))
		3327	return FALSE;
		3328
		3329	pslot = NULL;
		3330	if (flags != 3)
		3331	{
		3332	int pass;
		3333
		3334	/* We search from the last variable indices to the first in
		3335	hopes of finding local variables correctly. We search the
		3336	local variables on the first pass, and the global variables
		3337	on the second. FIXME: This probably won't work in all cases.
		3338	On the other hand, I don't know what will. */
		3339	for (pass = 0; pass < 2; pass++)
		3340	{
		3341	struct ieee_vars *vars;
		3342	int i;
		3343	struct ieee_var *pv = NULL;
		3344
		3345	if (pass == 0)
		3346	vars = &info->vars;
		3347	else
		3348	{
		3349	vars = info->global_vars;
		3350	if (vars == NULL)
		3351	break;
		3352	}
		3353
		3354	for (i = (int) vars->alloc - 1; i >= 0; i--)
		3355	{
		3356	bfd_boolean found;
		3357
		3358	pv = vars->vars + i;
		3359
		3360	if (pv->pslot == NULL
		3361	\|\| pv->namlen != namlen
		3362	\|\| strncmp (pv->name, name, namlen) != 0)
		3363	continue;
		3364
		3365	found = FALSE;
		3366	switch (flags)
		3367	{
		3368	default:
		3369	ieee_error (info, start,
		3370	_("unrecognized C++ reference type"));
		3371	return FALSE;
		3372
		3373	case 0:
		3374	/* Global variable or function. */
		3375	if (pv->kind == IEEE_GLOBAL
		3376	\|\| pv->kind == IEEE_EXTERNAL
		3377	\|\| pv->kind == IEEE_FUNCTION)
		3378	found = TRUE;
		3379	break;
		3380
		3381	case 1:
		3382	/* Global static variable or function. */
		3383	if (pv->kind == IEEE_STATIC
		3384	\|\| pv->kind == IEEE_FUNCTION)
		3385	found = TRUE;
		3386	break;
		3387
		3388	case 2:
		3389	/* Local variable. */
		3390	if (pv->kind == IEEE_LOCAL)
		3391	found = TRUE;
		3392	break;
		3393	}
		3394
		3395	if (found)
		3396	break;
		3397	}
		3398
		3399	if (i >= 0)
		3400	{
		3401	pslot = pv->pslot;
		3402	break;
		3403	}
		3404	}
		3405	}
		3406	else
		3407	{
		3408	struct ieee_tag *it;
		3409
		3410	for (it = info->tags; it != NULL; it = it->next)
		3411	{
		3412	if (it->name[0] == cxx_class[0]
		3413	&& strncmp (it->name, cxx_class, classlen) == 0
		3414	&& strlen (it->name) == classlen)
		3415	{
		3416	if (it->fslots != NULL)
		3417	{
		3418	const debug_field *pf;
		3419	unsigned int findx;
		3420
		3421	pf = debug_get_fields (info->dhandle, it->type);
		3422	if (pf == NULL)
		3423	{
		3424	ieee_error (info, start,
		3425	"C++ reference in class with no fields");
		3426	return FALSE;
		3427	}
		3428
		3429	for (findx = 0; *pf != DEBUG_FIELD_NULL; pf++, findx++)
		3430	{
		3431	const char *fname;
		3432
		3433	fname = debug_get_field_name (info->dhandle, *pf);
		3434	if (fname == NULL)
		3435	return FALSE;
		3436	if (strncmp (fname, name, namlen) == 0
		3437	&& strlen (fname) == namlen)
		3438	{
		3439	pslot = it->fslots + findx;
		3440	break;
		3441	}
		3442	}
		3443	}
		3444
		3445	break;
		3446	}
		3447	}
		3448	}
		3449
		3450	if (pslot == NULL)
		3451	{
		3452	ieee_error (info, start, _("C++ reference not found"));
		3453	return FALSE;
		3454	}
		3455
		3456	/* We allocated the type of the object as an indirect type pointing
		3457	to pslot, which we can now update to be a reference type. /
		3458	if (debug_get_type_kind (info->dhandle, *pslot) != DEBUG_KIND_POINTER)
		3459	{
		3460	ieee_error (info, start, _("C++ reference is not pointer"));
		3461	return FALSE;
		3462	}
		3463
		3464	target = debug_get_target_type (info->dhandle, *pslot);
		3465	*pslot = debug_make_reference_type (info->dhandle, target);
		3466	if (*pslot == DEBUG_TYPE_NULL)
		3467	return FALSE;
		3468
		3469	return TRUE;
		3470	}
		3471
		3472	/* Require an ASN record. */
		3473
		3474	static bfd_boolean
		3475	ieee_require_asn (struct ieee_info info, const bfd_byte pp, bfd_vma pv)
		3476	{
		3477	const bfd_byte *start;
		3478	ieee_record_enum_type c;
		3479	bfd_vma varindx;
		3480
		3481	start = *pp;
		3482
		3483	c = (ieee_record_enum_type) **pp;
		3484	if (c != ieee_e2_first_byte_enum)
		3485	{
		3486	ieee_error (info, start, _("missing required ASN"));
		3487	return FALSE;
		3488	}
		3489	++*pp;
		3490
		3491	c = (ieee_record_enum_type) (((unsigned int) c << 8) \| **pp);
		3492	if (c != ieee_asn_record_enum)
		3493	{
		3494	ieee_error (info, start, _("missing required ASN"));
		3495	return FALSE;
		3496	}
		3497	++*pp;
		3498
		3499	/* Just ignore the variable index. */
		3500	if (! ieee_read_number (info, pp, &varindx))
		3501	return FALSE;
		3502
		3503	return ieee_read_expression (info, pp, pv);
		3504	}
		3505
		3506	/* Require an ATN65 record. */
		3507
		3508	static bfd_boolean
		3509	ieee_require_atn65 (struct ieee_info info, const bfd_byte *pp,
		3510	const char *pname, unsigned long pnamlen)
		3511	{
		3512	const bfd_byte *start;
		3513	ieee_record_enum_type c;
		3514	bfd_vma name_indx, type_indx, atn_code;
		3515
		3516	start = *pp;
		3517
		3518	c = (ieee_record_enum_type) **pp;
		3519	if (c != ieee_at_record_enum)
		3520	{
		3521	ieee_error (info, start, _("missing required ATN65"));
		3522	return FALSE;
		3523	}
		3524	++*pp;
		3525
		3526	c = (ieee_record_enum_type) (((unsigned int) c << 8) \| **pp);
		3527	if (c != ieee_atn_record_enum)
		3528	{
		3529	ieee_error (info, start, _("missing required ATN65"));
		3530	return FALSE;
		3531	}
		3532	++*pp;
		3533
		3534	if (! ieee_read_number (info, pp, &name_indx)
		3535	\|\| ! ieee_read_number (info, pp, &type_indx)
		3536	\|\| ! ieee_read_number (info, pp, &atn_code))
		3537	return FALSE;
		3538
		3539	/* Just ignore name_indx. */
		3540
		3541	if (type_indx != 0 \|\| atn_code != 65)
		3542	{
		3543	ieee_error (info, start, _("bad ATN65 record"));
		3544	return FALSE;
		3545	}
		3546
		3547	return ieee_read_id (info, pp, pname, pnamlen);
		3548	}
		3549
		3550	/* Convert a register number in IEEE debugging information into a
		3551	generic register number. */
		3552
		3553	static int
		3554	ieee_regno_to_genreg (bfd *abfd, int r)
		3555	{
		3556	switch (bfd_get_arch (abfd))
		3557	{
		3558	case bfd_arch_m68k:
		3559	/* For some reasons stabs adds 2 to the floating point register
		3560	numbers. */
		3561	if (r >= 16)
		3562	r += 2;
		3563	break;
		3564
		3565	case bfd_arch_i960:
		3566	/* Stabs uses 0 to 15 for r0 to r15, 16 to 31 for g0 to g15, and
		3567	32 to 35 for fp0 to fp3. */
		3568	--r;
		3569	break;
		3570
		3571	default:
		3572	break;
		3573	}
		3574
		3575	return r;
		3576	}
		3577
		3578	/* Convert a generic register number to an IEEE specific one. */
		3579
		3580	static int
		3581	ieee_genreg_to_regno (bfd *abfd, int r)
		3582	{
		3583	switch (bfd_get_arch (abfd))
		3584	{
		3585	case bfd_arch_m68k:
		3586	/* For some reason stabs add 2 to the floating point register
		3587	numbers. */
		3588	if (r >= 18)
		3589	r -= 2;
		3590	break;
		3591
		3592	case bfd_arch_i960:
		3593	/* Stabs uses 0 to 15 for r0 to r15, 16 to 31 for g0 to g15, and
		3594	32 to 35 for fp0 to fp3. */
		3595	++r;
		3596	break;
		3597
		3598	default:
		3599	break;
		3600	}
		3601
		3602	return r;
		3603	}
		3604
		3605	/* These routines build IEEE debugging information out of the generic
		3606	debugging information. */
		3607
		3608	/* We build the IEEE debugging information byte by byte. Rather than
		3609	waste time copying data around, we use a linked list of buffers to
		3610	hold the data. */
		3611
		3612	#define IEEE_BUFSIZE (490)
		3613
		3614	struct ieee_buf
		3615	{
		3616	/* Next buffer. */
		3617	struct ieee_buf *next;
		3618	/* Number of data bytes in this buffer. */
		3619	unsigned int c;
		3620	/* Bytes. */
		3621	bfd_byte buf[IEEE_BUFSIZE];
		3622	};
		3623
		3624	/* A list of buffers. */
		3625
		3626	struct ieee_buflist
		3627	{
		3628	/* Head of list. */
		3629	struct ieee_buf *head;
		3630	/* Tail--last buffer on list. */
		3631	struct ieee_buf *tail;
		3632	};
		3633
		3634	/* In order to generate the BB11 blocks required by the HP emulator,
		3635	we keep track of ranges of addresses which correspond to a given
		3636	compilation unit. */
		3637
		3638	struct ieee_range
		3639	{
		3640	/* Next range. */
		3641	struct ieee_range *next;
		3642	/* Low address. */
		3643	bfd_vma low;
		3644	/* High address. */
		3645	bfd_vma high;
		3646	};
		3647
		3648	/* This structure holds information for a class on the type stack. */
		3649
		3650	struct ieee_type_class
		3651	{
		3652	/* The name index in the debugging information. */
		3653	unsigned int indx;
		3654	/* The pmisc records for the class. */
		3655	struct ieee_buflist pmiscbuf;
		3656	/* The number of pmisc records. */
		3657	unsigned int pmisccount;
		3658	/* The name of the class holding the virtual table, if not this
		3659	class. */
		3660	const char *vclass;
		3661	/* Whether this class holds its own virtual table. */
		3662	bfd_boolean ownvptr;
		3663	/* The largest virtual table offset seen so far. */
		3664	bfd_vma voffset;
		3665	/* The current method. */
		3666	const char *method;
		3667	/* Additional pmisc records used to record fields of reference type. */
		3668	struct ieee_buflist refs;
		3669	};
		3670
		3671	/* This is how we store types for the writing routines. Most types
		3672	are simply represented by a type index. */
		3673
		3674	struct ieee_write_type
		3675	{
		3676	/* Type index. */
		3677	unsigned int indx;
		3678	/* The size of the type, if known. */
		3679	unsigned int size;
		3680	/* The name of the type, if any. */
		3681	const char *name;
		3682	/* If this is a function or method type, we build the type here, and
		3683	only add it to the output buffers if we need it. */
		3684	struct ieee_buflist fndef;
		3685	/* If this is a struct, this is where the struct definition is
		3686	built. */
		3687	struct ieee_buflist strdef;
		3688	/* If this is a class, this is where the class information is built. */
		3689	struct ieee_type_class *classdef;
		3690	/* Whether the type is unsigned. */
		3691	unsigned int unsignedp : 1;
		3692	/* Whether this is a reference type. */
		3693	unsigned int referencep : 1;
		3694	/* Whether this is in the local type block. */
		3695	unsigned int localp : 1;
		3696	/* Whether this is a duplicate struct definition which we are
		3697	ignoring. */
		3698	unsigned int ignorep : 1;
		3699	};
		3700
		3701	/* This is the type stack used by the debug writing routines. FIXME:
		3702	We could generate more efficient output if we remembered when we
		3703	have output a particular type before. */
		3704
		3705	struct ieee_type_stack
		3706	{
		3707	/* Next entry on stack. */
		3708	struct ieee_type_stack *next;
		3709	/* Type information. */
		3710	struct ieee_write_type type;
		3711	};
		3712
		3713	/* This is a list of associations between a name and some types.
		3714	These are used for typedefs and tags. */
		3715
		3716	struct ieee_name_type
		3717	{
		3718	/* Next type for this name. */
		3719	struct ieee_name_type *next;
		3720	/* ID number. For a typedef, this is the index of the type to which
		3721	this name is typedefed. */
		3722	unsigned int id;
		3723	/* Type. */
		3724	struct ieee_write_type type;
		3725	/* If this is a tag which has not yet been defined, this is the
		3726	kind. If the tag has been defined, this is DEBUG_KIND_ILLEGAL. */
		3727	enum debug_type_kind kind;
		3728	};
		3729
		3730	/* We use a hash table to associate names and types. */
		3731
		3732	struct ieee_name_type_hash_table
		3733	{
		3734	struct bfd_hash_table root;
		3735	};
		3736
		3737	struct ieee_name_type_hash_entry
		3738	{
		3739	struct bfd_hash_entry root;
		3740	/* Information for this name. */
		3741	struct ieee_name_type *types;
		3742	};
		3743
		3744	/* This is a list of enums. */
		3745
		3746	struct ieee_defined_enum
		3747	{
		3748	/* Next enum. */
		3749	struct ieee_defined_enum *next;
		3750	/* Type index. */
		3751	unsigned int indx;
		3752	/* Whether this enum has been defined. */
		3753	bfd_boolean defined;
		3754	/* Tag. */
		3755	const char *tag;
		3756	/* Names. */
		3757	const char **names;
		3758	/* Values. */
		3759	bfd_signed_vma *vals;
		3760	};
		3761
		3762	/* We keep a list of modified versions of types, so that we don't
		3763	output them more than once. */
		3764
		3765	struct ieee_modified_type
		3766	{
		3767	/* Pointer to this type. */
		3768	unsigned int pointer;
		3769	/* Function with unknown arguments returning this type. */
		3770	unsigned int function;
		3771	/* Const version of this type. */
		3772	unsigned int const_qualified;
		3773	/* Volatile version of this type. */
		3774	unsigned int volatile_qualified;
		3775	/* List of arrays of this type of various bounds. */
		3776	struct ieee_modified_array_type *arrays;
		3777	};
		3778
		3779	/* A list of arrays bounds. */
		3780
		3781	struct ieee_modified_array_type
		3782	{
		3783	/* Next array bounds. */
		3784	struct ieee_modified_array_type *next;
		3785	/* Type index with these bounds. */
		3786	unsigned int indx;
		3787	/* Low bound. */
		3788	bfd_signed_vma low;
		3789	/* High bound. */
		3790	bfd_signed_vma high;
		3791	};
		3792
		3793	/* This is a list of pending function parameter information. We don't
		3794	output them until we see the first block. */
		3795
		3796	struct ieee_pending_parm
		3797	{
		3798	/* Next pending parameter. */
		3799	struct ieee_pending_parm *next;
		3800	/* Name. */
		3801	const char *name;
		3802	/* Type index. */
		3803	unsigned int type;
		3804	/* Whether the type is a reference. */
		3805	bfd_boolean referencep;
		3806	/* Kind. */
		3807	enum debug_parm_kind kind;
		3808	/* Value. */
		3809	bfd_vma val;
		3810	};
		3811
		3812	/* This is the handle passed down by debug_write. */
		3813
		3814	struct ieee_handle
		3815	{
		3816	/* BFD we are writing to. */
		3817	bfd *abfd;
		3818	/* Whether we got an error in a subroutine called via traverse or
		3819	map_over_sections. */
		3820	bfd_boolean error;
		3821	/* Current data buffer list. */
		3822	struct ieee_buflist *current;
		3823	/* Current data buffer. */
		3824	struct ieee_buf *curbuf;
		3825	/* Filename of current compilation unit. */
		3826	const char *filename;
		3827	/* Module name of current compilation unit. */
		3828	const char *modname;
		3829	/* List of buffer for global types. */
		3830	struct ieee_buflist global_types;
		3831	/* List of finished data buffers. */
		3832	struct ieee_buflist data;
		3833	/* List of buffers for typedefs in the current compilation unit. */
		3834	struct ieee_buflist types;
		3835	/* List of buffers for variables and functions in the current
		3836	compilation unit. */
		3837	struct ieee_buflist vars;
		3838	/* List of buffers for C++ class definitions in the current
		3839	compilation unit. */
		3840	struct ieee_buflist cxx;
		3841	/* List of buffers for line numbers in the current compilation unit. */
		3842	struct ieee_buflist linenos;
		3843	/* Ranges for the current compilation unit. */
		3844	struct ieee_range *ranges;
		3845	/* Ranges for all debugging information. */
		3846	struct ieee_range *global_ranges;
		3847	/* Nested pending ranges. */
		3848	struct ieee_range *pending_ranges;
		3849	/* Type stack. */
		3850	struct ieee_type_stack *type_stack;
		3851	/* Next unallocated type index. */
		3852	unsigned int type_indx;
		3853	/* Next unallocated name index. */
		3854	unsigned int name_indx;
		3855	/* Typedefs. */
		3856	struct ieee_name_type_hash_table typedefs;
		3857	/* Tags. */
		3858	struct ieee_name_type_hash_table tags;
		3859	/* Enums. */
		3860	struct ieee_defined_enum *enums;
		3861	/* Modified versions of types. */
		3862	struct ieee_modified_type *modified;
		3863	/* Number of entries allocated in modified. */
		3864	unsigned int modified_alloc;
		3865	/* 4 byte complex type. */
		3866	unsigned int complex_float_index;
		3867	/* 8 byte complex type. */
		3868	unsigned int complex_double_index;
		3869	/* The depth of block nesting. This is 0 outside a function, and 1
		3870	just after start_function is called. */
		3871	unsigned int block_depth;
		3872	/* The name of the current function. */
		3873	const char *fnname;
		3874	/* List of buffers for the type of the function we are currently
		3875	writing out. */
		3876	struct ieee_buflist fntype;
		3877	/* List of buffers for the parameters of the function we are
		3878	currently writing out. */
		3879	struct ieee_buflist fnargs;
		3880	/* Number of arguments written to fnargs. */
		3881	unsigned int fnargcount;
		3882	/* Pending function parameters. */
		3883	struct ieee_pending_parm *pending_parms;
		3884	/* Current line number filename. */
		3885	const char *lineno_filename;
		3886	/* Line number name index. */
		3887	unsigned int lineno_name_indx;
		3888	/* Filename of pending line number. */
		3889	const char *pending_lineno_filename;
		3890	/* Pending line number. */
		3891	unsigned long pending_lineno;
		3892	/* Address of pending line number. */
		3893	bfd_vma pending_lineno_addr;
		3894	/* Highest address seen at end of procedure. */
		3895	bfd_vma highaddr;
		3896	};
		3897
		3898	static bfd_boolean ieee_init_buffer
		3899	(struct ieee_handle , struct ieee_buflist );
		3900	static bfd_boolean ieee_change_buffer
		3901	(struct ieee_handle , struct ieee_buflist );
		3902	static bfd_boolean ieee_append_buffer
		3903	(struct ieee_handle , struct ieee_buflist , struct ieee_buflist *);
		3904	static bfd_boolean ieee_real_write_byte (struct ieee_handle *, int);
		3905	static bfd_boolean ieee_write_2bytes (struct ieee_handle *, int);
		3906	static bfd_boolean ieee_write_number (struct ieee_handle *, bfd_vma);
		3907	static bfd_boolean ieee_write_id (struct ieee_handle , const char );
		3908	static bfd_boolean ieee_write_asn
		3909	(struct ieee_handle *, unsigned int, bfd_vma);
		3910	static bfd_boolean ieee_write_atn65
		3911	(struct ieee_handle , unsigned int, const char );
		3912	static bfd_boolean ieee_push_type
		3913	(struct ieee_handle *, unsigned int, unsigned int, bfd_boolean,
		3914	bfd_boolean);
		3915	static unsigned int ieee_pop_type (struct ieee_handle *);
		3916	static void ieee_pop_unused_type (struct ieee_handle *);
		3917	static unsigned int ieee_pop_type_used (struct ieee_handle *, bfd_boolean);
		3918	static bfd_boolean ieee_add_range
		3919	(struct ieee_handle *, bfd_boolean, bfd_vma, bfd_vma);
		3920	static bfd_boolean ieee_start_range (struct ieee_handle *, bfd_vma);
		3921	static bfd_boolean ieee_end_range (struct ieee_handle *, bfd_vma);
		3922	static bfd_boolean ieee_define_type
		3923	(struct ieee_handle *, unsigned int, bfd_boolean, bfd_boolean);
		3924	static bfd_boolean ieee_define_named_type
		3925	(struct ieee_handle , const char , unsigned int, unsigned int,
		3926	bfd_boolean, bfd_boolean, struct ieee_buflist *);
		3927	static struct ieee_modified_type *ieee_get_modified_info
		3928	(struct ieee_handle *, unsigned int);
		3929	static struct bfd_hash_entry *ieee_name_type_newfunc
		3930	(struct bfd_hash_entry , struct bfd_hash_table , const char *);
		3931	static bfd_boolean ieee_write_undefined_tag
		3932	(struct ieee_name_type_hash_entry , void );
		3933	static bfd_boolean ieee_finish_compilation_unit (struct ieee_handle *);
		3934	static void ieee_add_bb11_blocks (bfd , asection , void *);
		3935	static bfd_boolean ieee_add_bb11
		3936	(struct ieee_handle , asection , bfd_vma, bfd_vma);
		3937	static bfd_boolean ieee_output_pending_parms (struct ieee_handle *);
		3938	static unsigned int ieee_vis_to_flags (enum debug_visibility);
		3939	static bfd_boolean ieee_class_method_var
		3940	(struct ieee_handle , const char , enum debug_visibility, bfd_boolean,
		3941	bfd_boolean, bfd_boolean, bfd_vma, bfd_boolean);
		3942
		3943	static bfd_boolean ieee_start_compilation_unit (void , const char );
		3944	static bfd_boolean ieee_start_source (void , const char );
		3945	static bfd_boolean ieee_empty_type (void *);
		3946	static bfd_boolean ieee_void_type (void *);
		3947	static bfd_boolean ieee_int_type (void *, unsigned int, bfd_boolean);
		3948	static bfd_boolean ieee_float_type (void *, unsigned int);
		3949	static bfd_boolean ieee_complex_type (void *, unsigned int);
		3950	static bfd_boolean ieee_bool_type (void *, unsigned int);
		3951	static bfd_boolean ieee_enum_type
		3952	(void , const char , const char *, bfd_signed_vma );
		3953	static bfd_boolean ieee_pointer_type (void *);
		3954	static bfd_boolean ieee_function_type (void *, int, bfd_boolean);
		3955	static bfd_boolean ieee_reference_type (void *);
		3956	static bfd_boolean ieee_range_type (void *, bfd_signed_vma, bfd_signed_vma);
		3957	static bfd_boolean ieee_array_type
		3958	(void *, bfd_signed_vma, bfd_signed_vma, bfd_boolean);
		3959	static bfd_boolean ieee_set_type (void *, bfd_boolean);
		3960	static bfd_boolean ieee_offset_type (void *);
		3961	static bfd_boolean ieee_method_type (void *, bfd_boolean, int, bfd_boolean);
		3962	static bfd_boolean ieee_const_type (void *);
		3963	static bfd_boolean ieee_volatile_type (void *);
		3964	static bfd_boolean ieee_start_struct_type
		3965	(void , const char , unsigned int, bfd_boolean, unsigned int);
		3966	static bfd_boolean ieee_struct_field
		3967	(void , const char , bfd_vma, bfd_vma, enum debug_visibility);
		3968	static bfd_boolean ieee_end_struct_type (void *);
		3969	static bfd_boolean ieee_start_class_type
		3970	(void , const char , unsigned int, bfd_boolean, unsigned int, bfd_boolean,
		3971	bfd_boolean);
		3972	static bfd_boolean ieee_class_static_member
		3973	(void , const char , const char *, enum debug_visibility);
		3974	static bfd_boolean ieee_class_baseclass
		3975	(void *, bfd_vma, bfd_boolean, enum debug_visibility);
		3976	static bfd_boolean ieee_class_start_method (void , const char );
		3977	static bfd_boolean ieee_class_method_variant
		3978	(void , const char , enum debug_visibility, bfd_boolean, bfd_boolean,
		3979	bfd_vma, bfd_boolean);
		3980	static bfd_boolean ieee_class_static_method_variant
		3981	(void , const char , enum debug_visibility, bfd_boolean, bfd_boolean);
		3982	static bfd_boolean ieee_class_end_method (void *);
		3983	static bfd_boolean ieee_end_class_type (void *);
		3984	static bfd_boolean ieee_typedef_type (void , const char );
		3985	static bfd_boolean ieee_tag_type
		3986	(void , const char , unsigned int, enum debug_type_kind);
		3987	static bfd_boolean ieee_typdef (void , const char );
		3988	static bfd_boolean ieee_tag (void , const char );
		3989	static bfd_boolean ieee_int_constant (void , const char , bfd_vma);
		3990	static bfd_boolean ieee_float_constant (void , const char , double);
		3991	static bfd_boolean ieee_typed_constant (void , const char , bfd_vma);
		3992	static bfd_boolean ieee_variable
		3993	(void , const char , enum debug_var_kind, bfd_vma);
		3994	static bfd_boolean ieee_start_function (void , const char , bfd_boolean);
		3995	static bfd_boolean ieee_function_parameter
		3996	(void , const char , enum debug_parm_kind, bfd_vma);
		3997	static bfd_boolean ieee_start_block (void *, bfd_vma);
		3998	static bfd_boolean ieee_end_block (void *, bfd_vma);
		3999	static bfd_boolean ieee_end_function (void *);
		4000	static bfd_boolean ieee_lineno (void , const char , unsigned long, bfd_vma);
		4001
		4002	static const struct debug_write_fns ieee_fns =
		4003	{
		4004	ieee_start_compilation_unit,
		4005	ieee_start_source,
		4006	ieee_empty_type,
		4007	ieee_void_type,
		4008	ieee_int_type,
		4009	ieee_float_type,
		4010	ieee_complex_type,
		4011	ieee_bool_type,
		4012	ieee_enum_type,
		4013	ieee_pointer_type,
		4014	ieee_function_type,
		4015	ieee_reference_type,
		4016	ieee_range_type,
		4017	ieee_array_type,
		4018	ieee_set_type,
		4019	ieee_offset_type,
		4020	ieee_method_type,
		4021	ieee_const_type,
		4022	ieee_volatile_type,
		4023	ieee_start_struct_type,
		4024	ieee_struct_field,
		4025	ieee_end_struct_type,
		4026	ieee_start_class_type,
		4027	ieee_class_static_member,
		4028	ieee_class_baseclass,
		4029	ieee_class_start_method,
		4030	ieee_class_method_variant,
		4031	ieee_class_static_method_variant,
		4032	ieee_class_end_method,
		4033	ieee_end_class_type,
		4034	ieee_typedef_type,
		4035	ieee_tag_type,
		4036	ieee_typdef,
		4037	ieee_tag,
		4038	ieee_int_constant,
		4039	ieee_float_constant,
		4040	ieee_typed_constant,
		4041	ieee_variable,
		4042	ieee_start_function,
		4043	ieee_function_parameter,
		4044	ieee_start_block,
		4045	ieee_end_block,
		4046	ieee_end_function,
		4047	ieee_lineno
		4048	};
		4049
		4050	/* Initialize a buffer to be empty. */
		4051
		4052	static bfd_boolean
		4053	ieee_init_buffer (struct ieee_handle *info ATTRIBUTE_UNUSED,
		4054	struct ieee_buflist *buflist)
		4055	{
		4056	buflist->head = NULL;
		4057	buflist->tail = NULL;
		4058	return TRUE;
		4059	}
		4060
		4061	/* See whether a buffer list has any data. */
		4062
		4063	#define ieee_buffer_emptyp(buflist) ((buflist)->head == NULL)
		4064
		4065	/* Change the current buffer to a specified buffer chain. */
		4066
		4067	static bfd_boolean
		4068	ieee_change_buffer (struct ieee_handle info, struct ieee_buflist buflist)
		4069	{
		4070	if (buflist->head == NULL)
		4071	{
		4072	struct ieee_buf *buf;
		4073
		4074	buf = (struct ieee_buf ) xmalloc (sizeof buf);
		4075	buf->next = NULL;
		4076	buf->c = 0;
		4077	buflist->head = buf;
		4078	buflist->tail = buf;
		4079	}
		4080
		4081	info->current = buflist;
		4082	info->curbuf = buflist->tail;
		4083
		4084	return TRUE;
		4085	}
		4086
		4087	/* Append a buffer chain. */
		4088
		4089	static bfd_boolean
		4090	ieee_append_buffer (struct ieee_handle *info ATTRIBUTE_UNUSED,
		4091	struct ieee_buflist *mainbuf,
		4092	struct ieee_buflist *newbuf)
		4093	{
		4094	if (newbuf->head != NULL)
		4095	{
		4096	if (mainbuf->head == NULL)
		4097	mainbuf->head = newbuf->head;
		4098	else
		4099	mainbuf->tail->next = newbuf->head;
		4100	mainbuf->tail = newbuf->tail;
		4101	}
		4102	return TRUE;
		4103	}
		4104
		4105	/* Write a byte into the buffer. We use a macro for speed and a
		4106	function for the complex cases. */
		4107
		4108	#define ieee_write_byte(info, b) \
		4109	((info)->curbuf->c < IEEE_BUFSIZE \
		4110	? ((info)->curbuf->buf[(info)->curbuf->c++] = (b), TRUE) \
		4111	: ieee_real_write_byte ((info), (b)))
		4112
		4113	static bfd_boolean
		4114	ieee_real_write_byte (struct ieee_handle *info, int b)
		4115	{
		4116	if (info->curbuf->c >= IEEE_BUFSIZE)
		4117	{
		4118	struct ieee_buf *n;
		4119
		4120	n = (struct ieee_buf ) xmalloc (sizeof n);
		4121	n->next = NULL;
		4122	n->c = 0;
		4123	if (info->current->head == NULL)
		4124	info->current->head = n;
		4125	else
		4126	info->current->tail->next = n;
		4127	info->current->tail = n;
		4128	info->curbuf = n;
		4129	}
		4130
		4131	info->curbuf->buf[info->curbuf->c] = b;
		4132	++info->curbuf->c;
		4133
		4134	return TRUE;
		4135	}
		4136
		4137	/* Write out two bytes. */
		4138
		4139	static bfd_boolean
		4140	ieee_write_2bytes (struct ieee_handle *info, int i)
		4141	{
		4142	return (ieee_write_byte (info, i >> 8)
		4143	&& ieee_write_byte (info, i & 0xff));
		4144	}
		4145
		4146	/* Write out an integer. */
		4147
		4148	static bfd_boolean
		4149	ieee_write_number (struct ieee_handle *info, bfd_vma v)
		4150	{
		4151	bfd_vma t;
		4152	bfd_byte ab[20];
		4153	bfd_byte *p;
		4154	unsigned int c;
		4155
		4156	if (v <= (bfd_vma) ieee_number_end_enum)
		4157	return ieee_write_byte (info, (int) v);
		4158
		4159	t = v;
		4160	p = ab + sizeof ab;
		4161	while (t != 0)
		4162	{
		4163	*--p = t & 0xff;
		4164	t >>= 8;
		4165	}
		4166	c = (ab + 20) - p;
		4167
		4168	if (c > (unsigned int) (ieee_number_repeat_end_enum
		4169	- ieee_number_repeat_start_enum))
		4170	{
		4171	fprintf (stderr, _("IEEE numeric overflow: 0x"));
		4172	fprintf_vma (stderr, v);
		4173	fprintf (stderr, "\n");
		4174	return FALSE;
		4175	}
		4176
		4177	if (! ieee_write_byte (info, (int) ieee_number_repeat_start_enum + c))
		4178	return FALSE;
		4179	for (; c > 0; --c, ++p)
		4180	{
		4181	if (! ieee_write_byte (info, *p))
		4182	return FALSE;
		4183	}
		4184
		4185	return TRUE;
		4186	}
		4187
		4188	/* Write out a string. */
		4189
		4190	static bfd_boolean
		4191	ieee_write_id (struct ieee_handle info, const char s)
		4192	{
		4193	unsigned int len;
		4194
		4195	len = strlen (s);
		4196	if (len <= 0x7f)
		4197	{
		4198	if (! ieee_write_byte (info, len))
		4199	return FALSE;
		4200	}
		4201	else if (len <= 0xff)
		4202	{
		4203	if (! ieee_write_byte (info, (int) ieee_extension_length_1_enum)
		4204	\|\| ! ieee_write_byte (info, len))
		4205	return FALSE;
		4206	}
		4207	else if (len <= 0xffff)
		4208	{
		4209	if (! ieee_write_byte (info, (int) ieee_extension_length_2_enum)
		4210	\|\| ! ieee_write_2bytes (info, len))
		4211	return FALSE;
		4212	}
		4213	else
		4214	{
		4215	fprintf (stderr, _("IEEE string length overflow: %u\n"), len);
		4216	return FALSE;
		4217	}
		4218
		4219	for (; *s != '\0'; s++)
		4220	if (! ieee_write_byte (info, *s))
		4221	return FALSE;
		4222
		4223	return TRUE;
		4224	}
		4225
		4226	/* Write out an ASN record. */
		4227
		4228	static bfd_boolean
		4229	ieee_write_asn (struct ieee_handle *info, unsigned int indx, bfd_vma val)
		4230	{
		4231	return (ieee_write_2bytes (info, (int) ieee_asn_record_enum)
		4232	&& ieee_write_number (info, indx)
		4233	&& ieee_write_number (info, val));
		4234	}
		4235
		4236	/* Write out an ATN65 record. */
		4237
		4238	static bfd_boolean
		4239	ieee_write_atn65 (struct ieee_handle info, unsigned int indx, const char s)
		4240	{
		4241	return (ieee_write_2bytes (info, (int) ieee_atn_record_enum)
		4242	&& ieee_write_number (info, indx)
		4243	&& ieee_write_number (info, 0)
		4244	&& ieee_write_number (info, 65)
		4245	&& ieee_write_id (info, s));
		4246	}
		4247
		4248	/* Push a type index onto the type stack. */
		4249
		4250	static bfd_boolean
		4251	ieee_push_type (struct ieee_handle *info, unsigned int indx,
		4252	unsigned int size, bfd_boolean unsignedp, bfd_boolean localp)
		4253	{
		4254	struct ieee_type_stack *ts;
		4255
		4256	ts = (struct ieee_type_stack ) xmalloc (sizeof ts);
		4257	memset (ts, 0, sizeof *ts);
		4258
		4259	ts->type.indx = indx;
		4260	ts->type.size = size;
		4261	ts->type.unsignedp = unsignedp;
		4262	ts->type.localp = localp;
		4263
		4264	ts->next = info->type_stack;
		4265	info->type_stack = ts;
		4266
		4267	return TRUE;
		4268	}
		4269
		4270	/* Pop a type index off the type stack. */
		4271
		4272	static unsigned int
		4273	ieee_pop_type (struct ieee_handle *info)
		4274	{
		4275	return ieee_pop_type_used (info, TRUE);
		4276	}
		4277
		4278	/* Pop an unused type index off the type stack. */
		4279
		4280	static void
		4281	ieee_pop_unused_type (struct ieee_handle *info)
		4282	{
		4283	(void) ieee_pop_type_used (info, FALSE);
		4284	}
		4285
		4286	/* Pop a used or unused type index off the type stack. */
		4287
		4288	static unsigned int
		4289	ieee_pop_type_used (struct ieee_handle *info, bfd_boolean used)
		4290	{
		4291	struct ieee_type_stack *ts;
		4292	unsigned int ret;
		4293
		4294	ts = info->type_stack;
		4295	assert (ts != NULL);
		4296
		4297	/* If this is a function type, and we need it, we need to append the
		4298	actual definition to the typedef block now. */
		4299	if (used && ! ieee_buffer_emptyp (&ts->type.fndef))
		4300	{
		4301	struct ieee_buflist *buflist;
		4302
		4303	if (ts->type.localp)
		4304	{
		4305	/* Make sure we have started the types block. */
		4306	if (ieee_buffer_emptyp (&info->types))
		4307	{
		4308	if (! ieee_change_buffer (info, &info->types)
		4309	\|\| ! ieee_write_byte (info, (int) ieee_bb_record_enum)
		4310	\|\| ! ieee_write_byte (info, 1)
		4311	\|\| ! ieee_write_number (info, 0)
		4312	\|\| ! ieee_write_id (info, info->modname))
		4313	return FALSE;
		4314	}
		4315	buflist = &info->types;
		4316	}
		4317	else
		4318	{
		4319	/* Make sure we started the global type block. */
		4320	if (ieee_buffer_emptyp (&info->global_types))
		4321	{
		4322	if (! ieee_change_buffer (info, &info->global_types)
		4323	\|\| ! ieee_write_byte (info, (int) ieee_bb_record_enum)
		4324	\|\| ! ieee_write_byte (info, 2)
		4325	\|\| ! ieee_write_number (info, 0)
		4326	\|\| ! ieee_write_id (info, ""))
		4327	return FALSE;
		4328	}
		4329	buflist = &info->global_types;
		4330	}
		4331
		4332	if (! ieee_append_buffer (info, buflist, &ts->type.fndef))
		4333	return FALSE;
		4334	}
		4335
		4336	ret = ts->type.indx;
		4337	info->type_stack = ts->next;
		4338	free (ts);
		4339	return ret;
		4340	}
		4341
		4342	/* Add a range of bytes included in the current compilation unit. */
		4343
		4344	static bfd_boolean
		4345	ieee_add_range (struct ieee_handle *info, bfd_boolean global, bfd_vma low,
		4346	bfd_vma high)
		4347	{
		4348	struct ieee_range *plist, r, **pr;
		4349
		4350	if (low == (bfd_vma) -1 \|\| high == (bfd_vma) -1 \|\| low == high)
		4351	return TRUE;
		4352
		4353	if (global)
		4354	plist = &info->global_ranges;
		4355	else
		4356	plist = &info->ranges;
		4357
		4358	for (r = *plist; r != NULL; r = r->next)
		4359	{
		4360	if (high >= r->low && low <= r->high)
		4361	{
		4362	/* The new range overlaps r. */
		4363	if (low < r->low)
		4364	r->low = low;
		4365	if (high > r->high)
		4366	r->high = high;
		4367	pr = &r->next;
		4368	while (pr != NULL && (pr)->low <= r->high)
		4369	{
		4370	struct ieee_range *n;
		4371
		4372	if ((*pr)->high > r->high)
		4373	r->high = (*pr)->high;
		4374	n = (*pr)->next;
		4375	free (*pr);
		4376	*pr = n;
		4377	}
		4378	return TRUE;
		4379	}
		4380	}
		4381
		4382	r = (struct ieee_range ) xmalloc (sizeof r);
		4383	memset (r, 0, sizeof *r);
		4384
		4385	r->low = low;
		4386	r->high = high;
		4387
		4388	/* Store the ranges sorted by address. */
		4389	for (pr = plist; pr != NULL; pr = &(pr)->next)
		4390	if ((*pr)->low > high)
		4391	break;
		4392	r->next = *pr;
		4393	*pr = r;
		4394
		4395	return TRUE;
		4396	}
		4397
		4398	/* Start a new range for which we only have the low address. */
		4399
		4400	static bfd_boolean
		4401	ieee_start_range (struct ieee_handle *info, bfd_vma low)
		4402	{
		4403	struct ieee_range *r;
		4404
		4405	r = (struct ieee_range ) xmalloc (sizeof r);
		4406	memset (r, 0, sizeof *r);
		4407	r->low = low;
		4408	r->next = info->pending_ranges;
		4409	info->pending_ranges = r;
		4410	return TRUE;
		4411	}
		4412
		4413	/* Finish a range started by ieee_start_range. */
		4414
		4415	static bfd_boolean
		4416	ieee_end_range (struct ieee_handle *info, bfd_vma high)
		4417	{
		4418	struct ieee_range *r;
		4419	bfd_vma low;
		4420
		4421	assert (info->pending_ranges != NULL);
		4422	r = info->pending_ranges;
		4423	low = r->low;
		4424	info->pending_ranges = r->next;
		4425	free (r);
		4426	return ieee_add_range (info, FALSE, low, high);
		4427	}
		4428
		4429	/* Start defining a type. */
		4430
		4431	static bfd_boolean
		4432	ieee_define_type (struct ieee_handle *info, unsigned int size,
		4433	bfd_boolean unsignedp, bfd_boolean localp)
		4434	{
		4435	return ieee_define_named_type (info, (const char *) NULL,
		4436	(unsigned int) -1, size, unsignedp,
		4437	localp, (struct ieee_buflist *) NULL);
		4438	}
		4439
		4440	/* Start defining a named type. */
		4441
		4442	static bfd_boolean
		4443	ieee_define_named_type (struct ieee_handle info, const char name,
		4444	unsigned int indx, unsigned int size,
		4445	bfd_boolean unsignedp, bfd_boolean localp,
		4446	struct ieee_buflist *buflist)
		4447	{
		4448	unsigned int type_indx;
		4449	unsigned int name_indx;
		4450
		4451	if (indx != (unsigned int) -1)
		4452	type_indx = indx;
		4453	else
		4454	{
		4455	type_indx = info->type_indx;
		4456	++info->type_indx;
		4457	}
		4458
		4459	name_indx = info->name_indx;
		4460	++info->name_indx;
		4461
		4462	if (name == NULL)
		4463	name = "";
		4464
		4465	/* If we were given a buffer, use it; otherwise, use either the
		4466	local or the global type information, and make sure that the type
		4467	block is started. */
		4468	if (buflist != NULL)
		4469	{
		4470	if (! ieee_change_buffer (info, buflist))
		4471	return FALSE;
		4472	}
		4473	else if (localp)
		4474	{
		4475	if (! ieee_buffer_emptyp (&info->types))
		4476	{
		4477	if (! ieee_change_buffer (info, &info->types))
		4478	return FALSE;
		4479	}
		4480	else
		4481	{
		4482	if (! ieee_change_buffer (info, &info->types)
		4483	\|\| ! ieee_write_byte (info, (int) ieee_bb_record_enum)
		4484	\|\| ! ieee_write_byte (info, 1)
		4485	\|\| ! ieee_write_number (info, 0)
		4486	\|\| ! ieee_write_id (info, info->modname))
		4487	return FALSE;
		4488	}
		4489	}
		4490	else
		4491	{
		4492	if (! ieee_buffer_emptyp (&info->global_types))
		4493	{
		4494	if (! ieee_change_buffer (info, &info->global_types))
		4495	return FALSE;
		4496	}
		4497	else
		4498	{
		4499	if (! ieee_change_buffer (info, &info->global_types)
		4500	\|\| ! ieee_write_byte (info, (int) ieee_bb_record_enum)
		4501	\|\| ! ieee_write_byte (info, 2)
		4502	\|\| ! ieee_write_number (info, 0)
		4503	\|\| ! ieee_write_id (info, ""))
		4504	return FALSE;
		4505	}
		4506	}
		4507
		4508	/* Push the new type on the type stack, write out an NN record, and
		4509	write out the start of a TY record. The caller will then finish
		4510	the TY record. */
		4511	if (! ieee_push_type (info, type_indx, size, unsignedp, localp))
		4512	return FALSE;
		4513
		4514	return (ieee_write_byte (info, (int) ieee_nn_record)
		4515	&& ieee_write_number (info, name_indx)
		4516	&& ieee_write_id (info, name)
		4517	&& ieee_write_byte (info, (int) ieee_ty_record_enum)
		4518	&& ieee_write_number (info, type_indx)
		4519	&& ieee_write_byte (info, 0xce)
		4520	&& ieee_write_number (info, name_indx));
		4521	}
		4522
		4523	/* Get an entry to the list of modified versions of a type. */
		4524
		4525	static struct ieee_modified_type *
		4526	ieee_get_modified_info (struct ieee_handle *info, unsigned int indx)
		4527	{
		4528	if (indx >= info->modified_alloc)
		4529	{
		4530	unsigned int nalloc;
		4531
		4532	nalloc = info->modified_alloc;
		4533	if (nalloc == 0)
		4534	nalloc = 16;
		4535	while (indx >= nalloc)
		4536	nalloc *= 2;
		4537	info->modified = ((struct ieee_modified_type *)
		4538	xrealloc (info->modified,
		4539	nalloc * sizeof *info->modified));
		4540	memset (info->modified + info->modified_alloc, 0,
		4541	(nalloc - info->modified_alloc) * sizeof *info->modified);
		4542	info->modified_alloc = nalloc;
		4543	}
		4544
		4545	return info->modified + indx;
		4546	}
		4547
		4548	/* Routines for the hash table mapping names to types. */
		4549
		4550	/* Initialize an entry in the hash table. */
		4551
		4552	static struct bfd_hash_entry *
		4553	ieee_name_type_newfunc (struct bfd_hash_entry *entry,
		4554	struct bfd_hash_table table, const char string)
		4555	{
		4556	struct ieee_name_type_hash_entry *ret =
		4557	(struct ieee_name_type_hash_entry *) entry;
		4558
		4559	/* Allocate the structure if it has not already been allocated by a
		4560	subclass. */
		4561	if (ret == NULL)
		4562	ret = ((struct ieee_name_type_hash_entry *)
		4563	bfd_hash_allocate (table, sizeof *ret));
		4564	if (ret == NULL)
		4565	return NULL;
		4566
		4567	/* Call the allocation method of the superclass. */
		4568	ret = ((struct ieee_name_type_hash_entry *)
		4569	bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
		4570	if (ret)
		4571	{
		4572	/* Set local fields. */
		4573	ret->types = NULL;
		4574	}
		4575
		4576	return (struct bfd_hash_entry *) ret;
		4577	}
		4578
		4579	/* Look up an entry in the hash table. */
		4580
		4581	#define ieee_name_type_hash_lookup(table, string, create, copy) \
		4582	((struct ieee_name_type_hash_entry *) \
		4583	bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
		4584
		4585	/* Traverse the hash table. */
		4586
		4587	#define ieee_name_type_hash_traverse(table, func, info) \
		4588	(bfd_hash_traverse \
		4589	(&(table)->root, \
		4590	(bfd_boolean () (struct bfd_hash_entry , void *)) (func), \
		4591	(info)))
		4592
		4593	/* The general routine to write out IEEE debugging information. */
		4594
		4595	bfd_boolean
		4596	write_ieee_debugging_info (bfd abfd, void dhandle)
		4597	{
		4598	struct ieee_handle info;
		4599	asection *s;
		4600	const char *err;
		4601	struct ieee_buf *b;
		4602
		4603	memset (&info, 0, sizeof info);
		4604	info.abfd = abfd;
		4605	info.type_indx = 256;
		4606	info.name_indx = 32;
		4607
		4608	if (!bfd_hash_table_init (&info.typedefs.root, ieee_name_type_newfunc,
		4609	sizeof (struct ieee_name_type_hash_entry))
		4610	\|\| !bfd_hash_table_init (&info.tags.root, ieee_name_type_newfunc,
		4611	sizeof (struct ieee_name_type_hash_entry)))
		4612	return FALSE;
		4613
		4614	if (! ieee_init_buffer (&info, &info.global_types)
		4615	\|\| ! ieee_init_buffer (&info, &info.data)
		4616	\|\| ! ieee_init_buffer (&info, &info.types)
		4617	\|\| ! ieee_init_buffer (&info, &info.vars)
		4618	\|\| ! ieee_init_buffer (&info, &info.cxx)
		4619	\|\| ! ieee_init_buffer (&info, &info.linenos)
		4620	\|\| ! ieee_init_buffer (&info, &info.fntype)
		4621	\|\| ! ieee_init_buffer (&info, &info.fnargs))
		4622	return FALSE;
		4623
		4624	if (! debug_write (dhandle, &ieee_fns, (void *) &info))
		4625	return FALSE;
		4626
		4627	if (info.filename != NULL)
		4628	{
		4629	if (! ieee_finish_compilation_unit (&info))
		4630	return FALSE;
		4631	}
		4632
		4633	/* Put any undefined tags in the global typedef information. */
		4634	info.error = FALSE;
		4635	ieee_name_type_hash_traverse (&info.tags,
		4636	ieee_write_undefined_tag,
		4637	(void *) &info);
		4638	if (info.error)
		4639	return FALSE;
		4640
		4641	/* Prepend the global typedef information to the other data. */
		4642	if (! ieee_buffer_emptyp (&info.global_types))
		4643	{
		4644	/* The HP debugger seems to have a bug in which it ignores the
		4645	last entry in the global types, so we add a dummy entry. */
		4646	if (! ieee_change_buffer (&info, &info.global_types)
		4647	\|\| ! ieee_write_byte (&info, (int) ieee_nn_record)
		4648	\|\| ! ieee_write_number (&info, info.name_indx)
		4649	\|\| ! ieee_write_id (&info, "")
		4650	\|\| ! ieee_write_byte (&info, (int) ieee_ty_record_enum)
		4651	\|\| ! ieee_write_number (&info, info.type_indx)
		4652	\|\| ! ieee_write_byte (&info, 0xce)
		4653	\|\| ! ieee_write_number (&info, info.name_indx)
		4654	\|\| ! ieee_write_number (&info, 'P')
		4655	\|\| ! ieee_write_number (&info, (int) builtin_void + 32)
		4656	\|\| ! ieee_write_byte (&info, (int) ieee_be_record_enum))
		4657	return FALSE;
		4658
		4659	if (! ieee_append_buffer (&info, &info.global_types, &info.data))
		4660	return FALSE;
		4661	info.data = info.global_types;
		4662	}
		4663
		4664	/* Make sure that we have declare BB11 blocks for each range in the
		4665	file. They are added to info->vars. */
		4666	info.error = FALSE;
		4667	if (! ieee_init_buffer (&info, &info.vars))
		4668	return FALSE;
		4669	bfd_map_over_sections (abfd, ieee_add_bb11_blocks, (void *) &info);
		4670	if (info.error)
		4671	return FALSE;
		4672	if (! ieee_buffer_emptyp (&info.vars))
		4673	{
		4674	if (! ieee_change_buffer (&info, &info.vars)
		4675	\|\| ! ieee_write_byte (&info, (int) ieee_be_record_enum))
		4676	return FALSE;
		4677
		4678	if (! ieee_append_buffer (&info, &info.data, &info.vars))
		4679	return FALSE;
		4680	}
		4681
		4682	/* Now all the data is in info.data. Write it out to the BFD. We
		4683	normally would need to worry about whether all the other sections
		4684	are set up yet, but the IEEE backend will handle this particular
		4685	case correctly regardless. */
		4686	if (ieee_buffer_emptyp (&info.data))
		4687	{
		4688	/* There is no debugging information. */
		4689	return TRUE;
		4690	}
		4691	err = NULL;
		4692	s = bfd_make_section_with_flags (abfd, ".debug",
		4693	SEC_DEBUGGING \| SEC_HAS_CONTENTS);
		4694	if (s == NULL)
		4695	err = "bfd_make_section";
		4696	if (err == NULL)
		4697	{
		4698	bfd_size_type size;
		4699
		4700	size = 0;
		4701	for (b = info.data.head; b != NULL; b = b->next)
		4702	size += b->c;
		4703	if (! bfd_set_section_size (abfd, s, size))
		4704	err = "bfd_set_section_size";
		4705	}
		4706	if (err == NULL)
		4707	{
		4708	file_ptr offset;
		4709
		4710	offset = 0;
		4711	for (b = info.data.head; b != NULL; b = b->next)
		4712	{
		4713	if (! bfd_set_section_contents (abfd, s, b->buf, offset, b->c))
		4714	{
		4715	err = "bfd_set_section_contents";
		4716	break;
		4717	}
		4718	offset += b->c;
		4719	}
		4720	}
		4721
		4722	if (err != NULL)
		4723	{
		4724	fprintf (stderr, "%s: %s: %s\n", bfd_get_filename (abfd), err,
		4725	bfd_errmsg (bfd_get_error ()));
		4726	return FALSE;
		4727	}
		4728
		4729	bfd_hash_table_free (&info.typedefs.root);
		4730	bfd_hash_table_free (&info.tags.root);
		4731
		4732	return TRUE;
		4733	}
		4734
		4735	/* Write out information for an undefined tag. This is called via
		4736	ieee_name_type_hash_traverse. */
		4737
		4738	static bfd_boolean
		4739	ieee_write_undefined_tag (struct ieee_name_type_hash_entry h, void p)
		4740	{
		4741	struct ieee_handle info = (struct ieee_handle ) p;
		4742	struct ieee_name_type *nt;
		4743
		4744	for (nt = h->types; nt != NULL; nt = nt->next)
		4745	{
		4746	unsigned int name_indx;
		4747	char code;
		4748
		4749	if (nt->kind == DEBUG_KIND_ILLEGAL)
		4750	continue;
		4751
		4752	if (ieee_buffer_emptyp (&info->global_types))
		4753	{
		4754	if (! ieee_change_buffer (info, &info->global_types)
		4755	\|\| ! ieee_write_byte (info, (int) ieee_bb_record_enum)
		4756	\|\| ! ieee_write_byte (info, 2)
		4757	\|\| ! ieee_write_number (info, 0)
		4758	\|\| ! ieee_write_id (info, ""))
		4759	{
		4760	info->error = TRUE;
		4761	return FALSE;
		4762	}
		4763	}
		4764	else
		4765	{
		4766	if (! ieee_change_buffer (info, &info->global_types))
		4767	{
		4768	info->error = TRUE;
		4769	return FALSE;
		4770	}
		4771	}
		4772
		4773	name_indx = info->name_indx;
		4774	++info->name_indx;
		4775	if (! ieee_write_byte (info, (int) ieee_nn_record)
		4776	\|\| ! ieee_write_number (info, name_indx)
		4777	\|\| ! ieee_write_id (info, nt->type.name)
		4778	\|\| ! ieee_write_byte (info, (int) ieee_ty_record_enum)
		4779	\|\| ! ieee_write_number (info, nt->type.indx)
		4780	\|\| ! ieee_write_byte (info, 0xce)
		4781	\|\| ! ieee_write_number (info, name_indx))
		4782	{
		4783	info->error = TRUE;
		4784	return FALSE;
		4785	}
		4786
		4787	switch (nt->kind)
		4788	{
		4789	default:
		4790	abort ();
		4791	info->error = TRUE;
		4792	return FALSE;
		4793	case DEBUG_KIND_STRUCT:
		4794	case DEBUG_KIND_CLASS:
		4795	code = 'S';
		4796	break;
		4797	case DEBUG_KIND_UNION:
		4798	case DEBUG_KIND_UNION_CLASS:
		4799	code = 'U';
		4800	break;
		4801	case DEBUG_KIND_ENUM:
		4802	code = 'E';
		4803	break;
		4804	}
		4805	if (! ieee_write_number (info, code)
		4806	\|\| ! ieee_write_number (info, 0))
		4807	{
		4808	info->error = TRUE;
		4809	return FALSE;
		4810	}
		4811	}
		4812
		4813	return TRUE;
		4814	}
		4815
		4816	/* Start writing out information for a compilation unit. */
		4817
		4818	static bfd_boolean
		4819	ieee_start_compilation_unit (void p, const char filename)
		4820	{
		4821	struct ieee_handle info = (struct ieee_handle ) p;
		4822	const char *modname;
		4823	#ifdef HAVE_DOS_BASED_FILE_SYSTEM
		4824	const char *backslash;
		4825	#endif
		4826	char c, s;
		4827
		4828	if (info->filename != NULL)
		4829	{
		4830	if (! ieee_finish_compilation_unit (info))
		4831	return FALSE;
		4832	}
		4833
		4834	info->filename = filename;
		4835	modname = strrchr (filename, '/');
		4836	#ifdef HAVE_DOS_BASED_FILE_SYSTEM
		4837	/* We could have a mixed forward/back slash case. */
		4838	backslash = strrchr (filename, '\\');
		4839	if (modname == NULL \|\| (backslash != NULL && backslash > modname))
		4840	modname = backslash;
		4841	#endif
		4842
		4843	if (modname != NULL)
		4844	++modname;
		4845	#ifdef HAVE_DOS_BASED_FILE_SYSTEM
		4846	else if (filename[0] && filename[1] == ':')
		4847	modname = filename + 2;
		4848	#endif
		4849	else
		4850	modname = filename;
		4851
		4852	c = xstrdup (modname);
		4853	s = strrchr (c, '.');
		4854	if (s != NULL)
		4855	*s = '\0';
		4856	info->modname = c;
		4857
		4858	if (! ieee_init_buffer (info, &info->types)
		4859	\|\| ! ieee_init_buffer (info, &info->vars)
		4860	\|\| ! ieee_init_buffer (info, &info->cxx)
		4861	\|\| ! ieee_init_buffer (info, &info->linenos))
		4862	return FALSE;
		4863	info->ranges = NULL;
		4864
		4865	/* Always include a BB1 and a BB3 block. That is what the output of
		4866	the MRI linker seems to look like. */
		4867	if (! ieee_change_buffer (info, &info->types)
		4868	\|\| ! ieee_write_byte (info, (int) ieee_bb_record_enum)
		4869	\|\| ! ieee_write_byte (info, 1)
		4870	\|\| ! ieee_write_number (info, 0)
		4871	\|\| ! ieee_write_id (info, info->modname))
		4872	return FALSE;
		4873
		4874	++info->name_indx;
		4875	if (! ieee_change_buffer (info, &info->vars)
		4876	\|\| ! ieee_write_byte (info, (int) ieee_bb_record_enum)
		4877	\|\| ! ieee_write_byte (info, 3)
		4878	\|\| ! ieee_write_number (info, 0)
		4879	\|\| ! ieee_write_id (info, info->modname))
		4880	return FALSE;
		4881
		4882	return TRUE;
		4883	}
		4884
		4885	/* Finish up a compilation unit. */
		4886
		4887	static bfd_boolean
		4888	ieee_finish_compilation_unit (struct ieee_handle *info)
		4889	{
		4890	struct ieee_range *r;
		4891
		4892	if (! ieee_buffer_emptyp (&info->types))
		4893	{
		4894	if (! ieee_change_buffer (info, &info->types)
		4895	\|\| ! ieee_write_byte (info, (int) ieee_be_record_enum))
		4896	return FALSE;
		4897	}
		4898
		4899	if (! ieee_buffer_emptyp (&info->cxx))
		4900	{
		4901	/* Append any C++ information to the global function and
		4902	variable information. */
		4903	assert (! ieee_buffer_emptyp (&info->vars));
		4904	if (! ieee_change_buffer (info, &info->vars))
		4905	return FALSE;
		4906
		4907	/* We put the pmisc records in a dummy procedure, just as the
		4908	MRI compiler does. */
		4909	if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
		4910	\|\| ! ieee_write_byte (info, 6)
		4911	\|\| ! ieee_write_number (info, 0)
		4912	\|\| ! ieee_write_id (info, "__XRYCPP")
		4913	\|\| ! ieee_write_number (info, 0)
		4914	\|\| ! ieee_write_number (info, 0)
		4915	\|\| ! ieee_write_number (info, info->highaddr - 1)
		4916	\|\| ! ieee_append_buffer (info, &info->vars, &info->cxx)
		4917	\|\| ! ieee_change_buffer (info, &info->vars)
		4918	\|\| ! ieee_write_byte (info, (int) ieee_be_record_enum)
		4919	\|\| ! ieee_write_number (info, info->highaddr - 1))
		4920	return FALSE;
		4921	}
		4922
		4923	if (! ieee_buffer_emptyp (&info->vars))
		4924	{
		4925	if (! ieee_change_buffer (info, &info->vars)
		4926	\|\| ! ieee_write_byte (info, (int) ieee_be_record_enum))
		4927	return FALSE;
		4928	}
		4929
		4930	if (info->pending_lineno_filename != NULL)
		4931	{
		4932	/* Force out the pending line number. */
		4933	if (! ieee_lineno ((void ) info, (const char ) NULL, 0, (bfd_vma) -1))
		4934	return FALSE;
		4935	}
		4936	if (! ieee_buffer_emptyp (&info->linenos))
		4937	{
		4938	if (! ieee_change_buffer (info, &info->linenos)
		4939	\|\| ! ieee_write_byte (info, (int) ieee_be_record_enum))
		4940	return FALSE;
		4941	if (filename_cmp (info->filename, info->lineno_filename) != 0)
		4942	{
		4943	/* We were not in the main file. We just closed the
		4944	included line number block, and now we must close the
		4945	main line number block. */
		4946	if (! ieee_write_byte (info, (int) ieee_be_record_enum))
		4947	return FALSE;
		4948	}
		4949	}
		4950
		4951	if (! ieee_append_buffer (info, &info->data, &info->types)
		4952	\|\| ! ieee_append_buffer (info, &info->data, &info->vars)
		4953	\|\| ! ieee_append_buffer (info, &info->data, &info->linenos))
		4954	return FALSE;
		4955
		4956	/* Build BB10/BB11 blocks based on the ranges we recorded. */
		4957	if (! ieee_change_buffer (info, &info->data))
		4958	return FALSE;
		4959
		4960	if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
		4961	\|\| ! ieee_write_byte (info, 10)
		4962	\|\| ! ieee_write_number (info, 0)
		4963	\|\| ! ieee_write_id (info, info->modname)
		4964	\|\| ! ieee_write_id (info, "")
		4965	\|\| ! ieee_write_number (info, 0)
		4966	\|\| ! ieee_write_id (info, "GNU objcopy"))
		4967	return FALSE;
		4968
		4969	for (r = info->ranges; r != NULL; r = r->next)
		4970	{
		4971	bfd_vma low, high;
		4972	asection *s;
		4973	int kind;
		4974
		4975	low = r->low;
		4976	high = r->high;
		4977
		4978	/* Find the section corresponding to this range. */
		4979	for (s = info->abfd->sections; s != NULL; s = s->next)
		4980	{
		4981	if (bfd_get_section_vma (info->abfd, s) <= low
		4982	&& high <= (bfd_get_section_vma (info->abfd, s)
		4983	+ bfd_section_size (info->abfd, s)))
		4984	break;
		4985	}
		4986
		4987	if (s == NULL)
		4988	{
		4989	/* Just ignore this range. */
		4990	continue;
		4991	}
		4992
		4993	/* Coalesce ranges if it seems reasonable. */
		4994	while (r->next != NULL
		4995	&& high + 0x1000 >= r->next->low
		4996	&& (r->next->high
		4997	<= (bfd_get_section_vma (info->abfd, s)
		4998	+ bfd_section_size (info->abfd, s))))
		4999	{
		5000	r = r->next;
		5001	high = r->high;
		5002	}
		5003
		5004	if ((s->flags & SEC_CODE) != 0)
		5005	kind = 1;
		5006	else if ((s->flags & SEC_READONLY) != 0)
		5007	kind = 3;
		5008	else
		5009	kind = 2;
		5010
		5011	if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
		5012	\|\| ! ieee_write_byte (info, 11)
		5013	\|\| ! ieee_write_number (info, 0)
		5014	\|\| ! ieee_write_id (info, "")
		5015	\|\| ! ieee_write_number (info, kind)
		5016	\|\| ! ieee_write_number (info, s->index + IEEE_SECTION_NUMBER_BASE)
		5017	\|\| ! ieee_write_number (info, low)
		5018	\|\| ! ieee_write_byte (info, (int) ieee_be_record_enum)
		5019	\|\| ! ieee_write_number (info, high - low))
		5020	return FALSE;
		5021
		5022	/* Add this range to the list of global ranges. */
		5023	if (! ieee_add_range (info, TRUE, low, high))
		5024	return FALSE;
		5025	}
		5026
		5027	if (! ieee_write_byte (info, (int) ieee_be_record_enum))
		5028	return FALSE;
		5029
		5030	return TRUE;
		5031	}
		5032
		5033	/* Add BB11 blocks describing each range that we have not already
		5034	described. */
		5035
		5036	static void
		5037	ieee_add_bb11_blocks (bfd abfd ATTRIBUTE_UNUSED, asection sec, void *data)
		5038	{
		5039	struct ieee_handle info = (struct ieee_handle ) data;
		5040	bfd_vma low, high;
		5041	struct ieee_range *r;
		5042
		5043	low = bfd_get_section_vma (abfd, sec);
		5044	high = low + bfd_section_size (abfd, sec);
		5045
		5046	/* Find the first range at or after this section. The ranges are
		5047	sorted by address. */
		5048	for (r = info->global_ranges; r != NULL; r = r->next)
		5049	if (r->high > low)
		5050	break;
		5051
		5052	while (low < high)
		5053	{
		5054	if (r == NULL \|\| r->low >= high)
		5055	{
		5056	if (! ieee_add_bb11 (info, sec, low, high))
		5057	info->error = TRUE;
		5058	return;
		5059	}
		5060
		5061	if (low < r->low
		5062	&& r->low - low > 0x100)
		5063	{
		5064	if (! ieee_add_bb11 (info, sec, low, r->low))
		5065	{
		5066	info->error = TRUE;
		5067	return;
		5068	}
		5069	}
		5070	low = r->high;
		5071
		5072	r = r->next;
		5073	}
		5074	}
		5075
		5076	/* Add a single BB11 block for a range. We add it to info->vars. */
		5077
		5078	static bfd_boolean
		5079	ieee_add_bb11 (struct ieee_handle info, asection sec, bfd_vma low,
		5080	bfd_vma high)
		5081	{
		5082	int kind;
		5083
		5084	if (! ieee_buffer_emptyp (&info->vars))
		5085	{
		5086	if (! ieee_change_buffer (info, &info->vars))
		5087	return FALSE;
		5088	}
		5089	else
		5090	{
		5091	const char filename, modname;
		5092	#ifdef HAVE_DOS_BASED_FILE_SYSTEM
		5093	const char *backslash;
		5094	#endif
		5095	char c, s;
		5096
		5097	/* Start the enclosing BB10 block. */
		5098	filename = bfd_get_filename (info->abfd);
		5099	modname = strrchr (filename, '/');
		5100	#ifdef HAVE_DOS_BASED_FILE_SYSTEM
		5101	backslash = strrchr (filename, '\\');
		5102	if (modname == NULL \|\| (backslash != NULL && backslash > modname))
		5103	modname = backslash;
		5104	#endif
		5105
		5106	if (modname != NULL)
		5107	++modname;
		5108	#ifdef HAVE_DOS_BASED_FILE_SYSTEM
		5109	else if (filename[0] && filename[1] == ':')
		5110	modname = filename + 2;
		5111	#endif
		5112	else
		5113	modname = filename;
		5114
		5115	c = xstrdup (modname);
		5116	s = strrchr (c, '.');
		5117	if (s != NULL)
		5118	*s = '\0';
		5119
		5120	if (! ieee_change_buffer (info, &info->vars)
		5121	\|\| ! ieee_write_byte (info, (int) ieee_bb_record_enum)
		5122	\|\| ! ieee_write_byte (info, 10)
		5123	\|\| ! ieee_write_number (info, 0)
		5124	\|\| ! ieee_write_id (info, c)
		5125	\|\| ! ieee_write_id (info, "")
		5126	\|\| ! ieee_write_number (info, 0)
		5127	\|\| ! ieee_write_id (info, "GNU objcopy"))
		5128	{
		5129	free (c);
		5130	return FALSE;
		5131	}
		5132
		5133	free (c);
		5134	}
		5135
		5136	if ((sec->flags & SEC_CODE) != 0)
		5137	kind = 1;
		5138	else if ((sec->flags & SEC_READONLY) != 0)
		5139	kind = 3;
		5140	else
		5141	kind = 2;
		5142
		5143	if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
		5144	\|\| ! ieee_write_byte (info, 11)
		5145	\|\| ! ieee_write_number (info, 0)
		5146	\|\| ! ieee_write_id (info, "")
		5147	\|\| ! ieee_write_number (info, kind)
		5148	\|\| ! ieee_write_number (info, sec->index + IEEE_SECTION_NUMBER_BASE)
		5149	\|\| ! ieee_write_number (info, low)
		5150	\|\| ! ieee_write_byte (info, (int) ieee_be_record_enum)
		5151	\|\| ! ieee_write_number (info, high - low))
		5152	return FALSE;
		5153
		5154	return TRUE;
		5155	}
		5156
		5157	/* Start recording information from a particular source file. This is
		5158	used to record which file defined which types, variables, etc. It
		5159	is not used for line numbers, since the lineno entry point passes
		5160	down the file name anyhow. IEEE debugging information doesn't seem
		5161	to store this information anywhere. */
		5162
		5163	static bfd_boolean
		5164	ieee_start_source (void *p ATTRIBUTE_UNUSED,
		5165	const char *filename ATTRIBUTE_UNUSED)
		5166	{
		5167	return TRUE;
		5168	}
		5169
		5170	/* Make an empty type. */
		5171
		5172	static bfd_boolean
		5173	ieee_empty_type (void *p)
		5174	{
		5175	struct ieee_handle info = (struct ieee_handle ) p;
		5176
		5177	return ieee_push_type (info, (int) builtin_unknown, 0, FALSE, FALSE);
		5178	}
		5179
		5180	/* Make a void type. */
		5181
		5182	static bfd_boolean
		5183	ieee_void_type (void *p)
		5184	{
		5185	struct ieee_handle info = (struct ieee_handle ) p;
		5186
		5187	return ieee_push_type (info, (int) builtin_void, 0, FALSE, FALSE);
		5188	}
		5189
		5190	/* Make an integer type. */
		5191
		5192	static bfd_boolean
		5193	ieee_int_type (void *p, unsigned int size, bfd_boolean unsignedp)
		5194	{
		5195	struct ieee_handle info = (struct ieee_handle ) p;
		5196	unsigned int indx;
		5197
		5198	switch (size)
		5199	{
		5200	case 1:
		5201	indx = (int) builtin_signed_char;
		5202	break;
		5203	case 2:
		5204	indx = (int) builtin_signed_short_int;
		5205	break;
		5206	case 4:
		5207	indx = (int) builtin_signed_long;
		5208	break;
		5209	case 8:
		5210	indx = (int) builtin_signed_long_long;
		5211	break;
		5212	default:
		5213	fprintf (stderr, _("IEEE unsupported integer type size %u\n"), size);
		5214	return FALSE;
		5215	}
		5216
		5217	if (unsignedp)
		5218	++indx;
		5219
		5220	return ieee_push_type (info, indx, size, unsignedp, FALSE);
		5221	}
		5222
		5223	/* Make a floating point type. */
		5224
		5225	static bfd_boolean
		5226	ieee_float_type (void *p, unsigned int size)
		5227	{
		5228	struct ieee_handle info = (struct ieee_handle ) p;
		5229	unsigned int indx;
		5230
		5231	switch (size)
		5232	{
		5233	case 4:
		5234	indx = (int) builtin_float;
		5235	break;
		5236	case 8:
		5237	indx = (int) builtin_double;
		5238	break;
		5239	case 12:
		5240	/* FIXME: This size really depends upon the processor. */
		5241	indx = (int) builtin_long_double;
		5242	break;
		5243	case 16:
		5244	indx = (int) builtin_long_long_double;
		5245	break;
		5246	default:
		5247	fprintf (stderr, _("IEEE unsupported float type size %u\n"), size);
		5248	return FALSE;
		5249	}
		5250
		5251	return ieee_push_type (info, indx, size, FALSE, FALSE);
		5252	}
		5253
		5254	/* Make a complex type. */
		5255
		5256	static bfd_boolean
		5257	ieee_complex_type (void *p, unsigned int size)
		5258	{
		5259	struct ieee_handle info = (struct ieee_handle ) p;
		5260	char code;
		5261
		5262	switch (size)
		5263	{
		5264	case 4:
		5265	if (info->complex_float_index != 0)
		5266	return ieee_push_type (info, info->complex_float_index, size * 2,
		5267	FALSE, FALSE);
		5268	code = 'c';
		5269	break;
		5270	case 12:
		5271	case 16:
		5272	/* These cases can be output by gcc -gstabs. Outputting the
		5273	wrong type is better than crashing. */
		5274	case 8:
		5275	if (info->complex_double_index != 0)
		5276	return ieee_push_type (info, info->complex_double_index, size * 2,
		5277	FALSE, FALSE);
		5278	code = 'd';
		5279	break;
		5280	default:
		5281	fprintf (stderr, _("IEEE unsupported complex type size %u\n"), size);
		5282	return FALSE;
		5283	}
		5284
		5285	/* FIXME: I don't know what the string is for. */
		5286	if (! ieee_define_type (info, size * 2, FALSE, FALSE)
		5287	\|\| ! ieee_write_number (info, code)
		5288	\|\| ! ieee_write_id (info, ""))
		5289	return FALSE;
		5290
		5291	if (size == 4)
		5292	info->complex_float_index = info->type_stack->type.indx;
		5293	else
		5294	info->complex_double_index = info->type_stack->type.indx;
		5295
		5296	return TRUE;
		5297	}
		5298
		5299	/* Make a boolean type. IEEE doesn't support these, so we just make
		5300	an integer type instead. */
		5301
		5302	static bfd_boolean
		5303	ieee_bool_type (void *p, unsigned int size)
		5304	{
		5305	return ieee_int_type (p, size, TRUE);
		5306	}
		5307
		5308	/* Make an enumeration. */
		5309
		5310	static bfd_boolean
		5311	ieee_enum_type (void p, const char tag, const char **names,
		5312	bfd_signed_vma *vals)
		5313	{
		5314	struct ieee_handle info = (struct ieee_handle ) p;
		5315	struct ieee_defined_enum *e;
		5316	bfd_boolean localp, simple;
		5317	unsigned int indx;
		5318	int i = 0;
		5319
		5320	localp = FALSE;
		5321	indx = (unsigned int) -1;
		5322	for (e = info->enums; e != NULL; e = e->next)
		5323	{
		5324	if (tag == NULL)
		5325	{
		5326	if (e->tag != NULL)
		5327	continue;
		5328	}
		5329	else
		5330	{
		5331	if (e->tag == NULL
		5332	\|\| tag[0] != e->tag[0]
		5333	\|\| strcmp (tag, e->tag) != 0)
		5334	continue;
		5335	}
		5336
		5337	if (! e->defined)
		5338	{
		5339	/* This enum tag has been seen but not defined. */
		5340	indx = e->indx;
		5341	break;
		5342	}
		5343
		5344	if (names != NULL && e->names != NULL)
		5345	{
		5346	for (i = 0; names[i] != NULL && e->names[i] != NULL; i++)
		5347	{
		5348	if (names[i][0] != e->names[i][0]
		5349	\|\| vals[i] != e->vals[i]
		5350	\|\| strcmp (names[i], e->names[i]) != 0)
		5351	break;
		5352	}
		5353	}
		5354
		5355	if ((names == NULL && e->names == NULL)
		5356	\|\| (names != NULL
		5357	&& e->names != NULL
		5358	&& names[i] == NULL
		5359	&& e->names[i] == NULL))
		5360	{
		5361	/* We've seen this enum before. */
		5362	return ieee_push_type (info, e->indx, 0, TRUE, FALSE);
		5363	}
		5364
		5365	if (tag != NULL)
		5366	{
		5367	/* We've already seen an enum of the same name, so we must make
		5368	sure to output this one locally. */
		5369	localp = TRUE;
		5370	break;
		5371	}
		5372	}
		5373
		5374	/* If this is a simple enumeration, in which the values start at 0
		5375	and always increment by 1, we can use type E. Otherwise we must
		5376	use type N. */
		5377
		5378	simple = TRUE;
		5379	if (names != NULL)
		5380	{
		5381	for (i = 0; names[i] != NULL; i++)
		5382	{
		5383	if (vals[i] != i)
		5384	{
		5385	simple = FALSE;
		5386	break;
		5387	}
		5388	}
		5389	}
		5390
		5391	if (! ieee_define_named_type (info, tag, indx, 0, TRUE, localp,
		5392	(struct ieee_buflist *) NULL)
		5393	\|\| ! ieee_write_number (info, simple ? 'E' : 'N'))
		5394	return FALSE;
		5395	if (simple)
		5396	{
		5397	/* FIXME: This is supposed to be the enumeration size, but we
		5398	don't store that. */
		5399	if (! ieee_write_number (info, 4))
		5400	return FALSE;
		5401	}
		5402	if (names != NULL)
		5403	{
		5404	for (i = 0; names[i] != NULL; i++)
		5405	{
		5406	if (! ieee_write_id (info, names[i]))
		5407	return FALSE;
		5408	if (! simple)
		5409	{
		5410	if (! ieee_write_number (info, vals[i]))
		5411	return FALSE;
		5412	}
		5413	}
		5414	}
		5415
		5416	if (! localp)
		5417	{
		5418	if (indx == (unsigned int) -1)
		5419	{
		5420	e = (struct ieee_defined_enum ) xmalloc (sizeof e);
		5421	memset (e, 0, sizeof *e);
		5422	e->indx = info->type_stack->type.indx;
		5423	e->tag = tag;
		5424
		5425	e->next = info->enums;
		5426	info->enums = e;
		5427	}
		5428
		5429	e->names = names;
		5430	e->vals = vals;
		5431	e->defined = TRUE;
		5432	}
		5433
		5434	return TRUE;
		5435	}
		5436
		5437	/* Make a pointer type. */
		5438
		5439	static bfd_boolean
		5440	ieee_pointer_type (void *p)
		5441	{
		5442	struct ieee_handle info = (struct ieee_handle ) p;
		5443	bfd_boolean localp;
		5444	unsigned int indx;
		5445	struct ieee_modified_type *m = NULL;
		5446
		5447	localp = info->type_stack->type.localp;
		5448	indx = ieee_pop_type (info);
		5449
		5450	/* A pointer to a simple builtin type can be obtained by adding 32.
		5451	FIXME: Will this be a short pointer, and will that matter? */
		5452	if (indx < 32)
		5453	return ieee_push_type (info, indx + 32, 0, TRUE, FALSE);
		5454
		5455	if (! localp)
		5456	{
		5457	m = ieee_get_modified_info ((struct ieee_handle *) p, indx);
		5458	if (m == NULL)
		5459	return FALSE;
		5460
		5461	/* FIXME: The size should depend upon the architecture. */
		5462	if (m->pointer > 0)
		5463	return ieee_push_type (info, m->pointer, 4, TRUE, FALSE);
		5464	}
		5465
		5466	if (! ieee_define_type (info, 4, TRUE, localp)
		5467	\|\| ! ieee_write_number (info, 'P')
		5468	\|\| ! ieee_write_number (info, indx))
		5469	return FALSE;
		5470
		5471	if (! localp)
		5472	m->pointer = info->type_stack->type.indx;
		5473
		5474	return TRUE;
		5475	}
		5476
		5477	/* Make a function type. This will be called for a method, but we
		5478	don't want to actually add it to the type table in that case. We
		5479	handle this by defining the type in a private buffer, and only
		5480	adding that buffer to the typedef block if we are going to use it. */
		5481
		5482	static bfd_boolean
		5483	ieee_function_type (void *p, int argcount, bfd_boolean varargs)
		5484	{
		5485	struct ieee_handle info = (struct ieee_handle ) p;
		5486	bfd_boolean localp;
		5487	unsigned int *args = NULL;
		5488	int i;
		5489	unsigned int retindx;
		5490	struct ieee_buflist fndef;
		5491	struct ieee_modified_type *m;
		5492
		5493	localp = FALSE;
		5494
		5495	if (argcount > 0)
		5496	{
		5497	args = (unsigned int ) xmalloc (argcount sizeof *args);
		5498	for (i = argcount - 1; i >= 0; i--)
		5499	{
		5500	if (info->type_stack->type.localp)
		5501	localp = TRUE;
		5502	args[i] = ieee_pop_type (info);
		5503	}
		5504	}
		5505	else if (argcount < 0)
		5506	varargs = FALSE;
		5507
		5508	if (info->type_stack->type.localp)
		5509	localp = TRUE;
		5510	retindx = ieee_pop_type (info);
		5511
		5512	m = NULL;
		5513	if (argcount < 0 && ! localp)
		5514	{
		5515	m = ieee_get_modified_info ((struct ieee_handle *) p, retindx);
		5516	if (m == NULL)
		5517	return FALSE;
		5518
		5519	if (m->function > 0)
		5520	return ieee_push_type (info, m->function, 0, TRUE, FALSE);
		5521	}
		5522
		5523	/* An attribute of 0x41 means that the frame and push mask are
		5524	unknown. */
		5525	if (! ieee_init_buffer (info, &fndef)
		5526	\|\| ! ieee_define_named_type (info, (const char *) NULL,
		5527	(unsigned int) -1, 0, TRUE, localp,
		5528	&fndef)
		5529	\|\| ! ieee_write_number (info, 'x')
		5530	\|\| ! ieee_write_number (info, 0x41)
		5531	\|\| ! ieee_write_number (info, 0)
		5532	\|\| ! ieee_write_number (info, 0)
		5533	\|\| ! ieee_write_number (info, retindx)
		5534	\|\| ! ieee_write_number (info, (bfd_vma) argcount + (varargs ? 1 : 0)))
		5535	{
		5536	free (args);
		5537	return FALSE;
		5538	}
		5539	if (argcount > 0)
		5540	{
		5541	for (i = 0; i < argcount; i++)
		5542	if (! ieee_write_number (info, args[i]))
		5543	return FALSE;
		5544	free (args);
		5545	}
		5546	if (varargs)
		5547	{
		5548	/* A varargs function is represented by writing out the last
		5549	argument as type void , although this makes little sense. /
		5550	if (! ieee_write_number (info, (bfd_vma) builtin_void + 32))
		5551	return FALSE;
		5552	}
		5553
		5554	if (! ieee_write_number (info, 0))
		5555	return FALSE;
		5556
		5557	/* We wrote the information into fndef, in case we don't need it.
		5558	It will be appended to info->types by ieee_pop_type. */
		5559	info->type_stack->type.fndef = fndef;
		5560
		5561	if (m != NULL)
		5562	m->function = info->type_stack->type.indx;
		5563
		5564	return TRUE;
		5565	}
		5566
		5567	/* Make a reference type. */
		5568
		5569	static bfd_boolean
		5570	ieee_reference_type (void *p)
		5571	{
		5572	struct ieee_handle info = (struct ieee_handle ) p;
		5573
		5574	/* IEEE appears to record a normal pointer type, and then use a
		5575	pmisc record to indicate that it is really a reference. */
		5576
		5577	if (! ieee_pointer_type (p))
		5578	return FALSE;
		5579	info->type_stack->type.referencep = TRUE;
		5580	return TRUE;
		5581	}
		5582
		5583	/* Make a range type. */
		5584
		5585	static bfd_boolean
		5586	ieee_range_type (void *p, bfd_signed_vma low, bfd_signed_vma high)
		5587	{
		5588	struct ieee_handle info = (struct ieee_handle ) p;
		5589	unsigned int size;
		5590	bfd_boolean unsignedp, localp;
		5591
		5592	size = info->type_stack->type.size;
		5593	unsignedp = info->type_stack->type.unsignedp;
		5594	localp = info->type_stack->type.localp;
		5595	ieee_pop_unused_type (info);
		5596	return (ieee_define_type (info, size, unsignedp, localp)
		5597	&& ieee_write_number (info, 'R')
		5598	&& ieee_write_number (info, (bfd_vma) low)
		5599	&& ieee_write_number (info, (bfd_vma) high)
		5600	&& ieee_write_number (info, unsignedp ? 0 : 1)
		5601	&& ieee_write_number (info, size));
		5602	}
		5603
		5604	/* Make an array type. */
		5605
		5606	static bfd_boolean
		5607	ieee_array_type (void *p, bfd_signed_vma low, bfd_signed_vma high,
		5608	bfd_boolean stringp ATTRIBUTE_UNUSED)
		5609	{
		5610	struct ieee_handle info = (struct ieee_handle ) p;
		5611	unsigned int eleindx;
		5612	bfd_boolean localp;
		5613	unsigned int size;
		5614	struct ieee_modified_type *m = NULL;
		5615	struct ieee_modified_array_type *a;
		5616
		5617	/* IEEE does not store the range, so we just ignore it. */
		5618	ieee_pop_unused_type (info);
		5619	localp = info->type_stack->type.localp;
		5620	size = info->type_stack->type.size;
		5621	eleindx = ieee_pop_type (info);
		5622
		5623	/* If we don't know the range, treat the size as exactly one
		5624	element. */
		5625	if (low < high)
		5626	size *= (high - low) + 1;
		5627
		5628	if (! localp)
		5629	{
		5630	m = ieee_get_modified_info (info, eleindx);
		5631	if (m == NULL)
		5632	return FALSE;
		5633
		5634	for (a = m->arrays; a != NULL; a = a->next)
		5635	{
		5636	if (a->low == low && a->high == high)
		5637	return ieee_push_type (info, a->indx, size, FALSE, FALSE);
		5638	}
		5639	}
		5640
		5641	if (! ieee_define_type (info, size, FALSE, localp)
		5642	\|\| ! ieee_write_number (info, low == 0 ? 'Z' : 'C')
		5643	\|\| ! ieee_write_number (info, eleindx))
		5644	return FALSE;
		5645	if (low != 0)
		5646	{
		5647	if (! ieee_write_number (info, low))
		5648	return FALSE;
		5649	}
		5650
		5651	if (! ieee_write_number (info, high + 1))
		5652	return FALSE;
		5653
		5654	if (! localp)
		5655	{
		5656	a = (struct ieee_modified_array_type ) xmalloc (sizeof a);
		5657	memset (a, 0, sizeof *a);
		5658
		5659	a->indx = info->type_stack->type.indx;
		5660	a->low = low;
		5661	a->high = high;
		5662
		5663	a->next = m->arrays;
		5664	m->arrays = a;
		5665	}
		5666
		5667	return TRUE;
		5668	}
		5669
		5670	/* Make a set type. */
		5671
		5672	static bfd_boolean
		5673	ieee_set_type (void *p, bfd_boolean bitstringp ATTRIBUTE_UNUSED)
		5674	{
		5675	struct ieee_handle info = (struct ieee_handle ) p;
		5676	bfd_boolean localp;
		5677	unsigned int eleindx;
		5678
		5679	localp = info->type_stack->type.localp;
		5680	eleindx = ieee_pop_type (info);
		5681
		5682	/* FIXME: We don't know the size, so we just use 4. */
		5683
		5684	return (ieee_define_type (info, 0, TRUE, localp)
		5685	&& ieee_write_number (info, 's')
		5686	&& ieee_write_number (info, 4)
		5687	&& ieee_write_number (info, eleindx));
		5688	}
		5689
		5690	/* Make an offset type. */
		5691
		5692	static bfd_boolean
		5693	ieee_offset_type (void *p)
		5694	{
		5695	/* FIXME: The MRI C++ compiler does not appear to generate any
		5696	useful type information about an offset type. It just records a
		5697	pointer to member as an integer. The MRI/HP IEEE spec does
		5698	describe a pmisc record which can be used for a pointer to
		5699	member. Unfortunately, it does not describe the target type,
		5700	which seems pretty important. I'm going to punt this for now. */
		5701
		5702	return ieee_int_type (p, 4, TRUE);
		5703	}
		5704
		5705	/* Make a method type. */
		5706
		5707	static bfd_boolean
		5708	ieee_method_type (void *p, bfd_boolean domain, int argcount,
		5709	bfd_boolean varargs)
		5710	{
		5711	struct ieee_handle info = (struct ieee_handle ) p;
		5712
		5713	/* FIXME: The MRI/HP IEEE spec defines a pmisc record to use for a
		5714	method, but the definition is incomplete. We just output an 'x'
		5715	type. */
		5716
		5717	if (domain)
		5718	ieee_pop_unused_type (info);
		5719
		5720	return ieee_function_type (p, argcount, varargs);
		5721	}
		5722
		5723	/* Make a const qualified type. */
		5724
		5725	static bfd_boolean
		5726	ieee_const_type (void *p)
		5727	{
		5728	struct ieee_handle info = (struct ieee_handle ) p;
		5729	unsigned int size;
		5730	bfd_boolean unsignedp, localp;
		5731	unsigned int indx;
		5732	struct ieee_modified_type *m = NULL;
		5733
		5734	size = info->type_stack->type.size;
		5735	unsignedp = info->type_stack->type.unsignedp;
		5736	localp = info->type_stack->type.localp;
		5737	indx = ieee_pop_type (info);
		5738
		5739	if (! localp)
		5740	{
		5741	m = ieee_get_modified_info (info, indx);
		5742	if (m == NULL)
		5743	return FALSE;
		5744
		5745	if (m->const_qualified > 0)
		5746	return ieee_push_type (info, m->const_qualified, size, unsignedp,
		5747	FALSE);
		5748	}
		5749
		5750	if (! ieee_define_type (info, size, unsignedp, localp)
		5751	\|\| ! ieee_write_number (info, 'n')
		5752	\|\| ! ieee_write_number (info, 1)
		5753	\|\| ! ieee_write_number (info, indx))
		5754	return FALSE;
		5755
		5756	if (! localp)
		5757	m->const_qualified = info->type_stack->type.indx;
		5758
		5759	return TRUE;
		5760	}
		5761
		5762	/* Make a volatile qualified type. */
		5763
		5764	static bfd_boolean
		5765	ieee_volatile_type (void *p)
		5766	{
		5767	struct ieee_handle info = (struct ieee_handle ) p;
		5768	unsigned int size;
		5769	bfd_boolean unsignedp, localp;
		5770	unsigned int indx;
		5771	struct ieee_modified_type *m = NULL;
		5772
		5773	size = info->type_stack->type.size;
		5774	unsignedp = info->type_stack->type.unsignedp;
		5775	localp = info->type_stack->type.localp;
		5776	indx = ieee_pop_type (info);
		5777
		5778	if (! localp)
		5779	{
		5780	m = ieee_get_modified_info (info, indx);
		5781	if (m == NULL)
		5782	return FALSE;
		5783
		5784	if (m->volatile_qualified > 0)
		5785	return ieee_push_type (info, m->volatile_qualified, size, unsignedp,
		5786	FALSE);
		5787	}
		5788
		5789	if (! ieee_define_type (info, size, unsignedp, localp)
		5790	\|\| ! ieee_write_number (info, 'n')
		5791	\|\| ! ieee_write_number (info, 2)
		5792	\|\| ! ieee_write_number (info, indx))
		5793	return FALSE;
		5794
		5795	if (! localp)
		5796	m->volatile_qualified = info->type_stack->type.indx;
		5797
		5798	return TRUE;
		5799	}
		5800
		5801	/* Convert an enum debug_visibility into a CXXFLAGS value. */
		5802
		5803	static unsigned int
		5804	ieee_vis_to_flags (enum debug_visibility visibility)
		5805	{
		5806	switch (visibility)
		5807	{
		5808	default:
		5809	abort ();
		5810	case DEBUG_VISIBILITY_PUBLIC:
		5811	return CXXFLAGS_VISIBILITY_PUBLIC;
		5812	case DEBUG_VISIBILITY_PRIVATE:
		5813	return CXXFLAGS_VISIBILITY_PRIVATE;
		5814	case DEBUG_VISIBILITY_PROTECTED:
		5815	return CXXFLAGS_VISIBILITY_PROTECTED;
		5816	}
		5817	/NOTREACHED/
		5818	}
		5819
		5820	/* Start defining a struct type. We build it in the strdef field on
		5821	the stack, to avoid confusing type definitions required by the
		5822	fields with the struct type itself. */
		5823
		5824	static bfd_boolean
		5825	ieee_start_struct_type (void p, const char tag, unsigned int id,
		5826	bfd_boolean structp, unsigned int size)
		5827	{
		5828	struct ieee_handle info = (struct ieee_handle ) p;
		5829	bfd_boolean localp, ignorep;
		5830	bfd_boolean copy;
		5831	char ab[20];
		5832	const char *look;
		5833	struct ieee_name_type_hash_entry *h;
		5834	struct ieee_name_type nt, ntlook;
		5835	struct ieee_buflist strdef;
		5836
		5837	localp = FALSE;
		5838	ignorep = FALSE;
		5839
		5840	/* We need to create a tag for internal use even if we don't want
		5841	one for external use. This will let us refer to an anonymous
		5842	struct. */
		5843	if (tag != NULL)
		5844	{
		5845	look = tag;
		5846	copy = FALSE;
		5847	}
		5848	else
		5849	{
		5850	sprintf (ab, "__anon%u", id);
		5851	look = ab;
		5852	copy = TRUE;
		5853	}
		5854
		5855	/* If we already have references to the tag, we must use the
		5856	existing type index. */
		5857	h = ieee_name_type_hash_lookup (&info->tags, look, TRUE, copy);
		5858	if (h == NULL)
		5859	return FALSE;
		5860
		5861	nt = NULL;
		5862	for (ntlook = h->types; ntlook != NULL; ntlook = ntlook->next)
		5863	{
		5864	if (ntlook->id == id)
		5865	nt = ntlook;
		5866	else if (! ntlook->type.localp)
		5867	{
		5868	/* We are creating a duplicate definition of a globally
		5869	defined tag. Force it to be local to avoid
		5870	confusion. */
		5871	localp = TRUE;
		5872	}
		5873	}
		5874
		5875	if (nt != NULL)
		5876	{
		5877	assert (localp == nt->type.localp);
		5878	if (nt->kind == DEBUG_KIND_ILLEGAL && ! localp)
		5879	{
		5880	/* We've already seen a global definition of the type.
		5881	Ignore this new definition. */
		5882	ignorep = TRUE;
		5883	}
		5884	}
		5885	else
		5886	{
		5887	nt = (struct ieee_name_type ) xmalloc (sizeof nt);
		5888	memset (nt, 0, sizeof *nt);
		5889	nt->id = id;
		5890	nt->type.name = h->root.string;
		5891	nt->next = h->types;
		5892	h->types = nt;
		5893	nt->type.indx = info->type_indx;
		5894	++info->type_indx;
		5895	}
		5896
		5897	nt->kind = DEBUG_KIND_ILLEGAL;
		5898
		5899	if (! ieee_init_buffer (info, &strdef)
		5900	\|\| ! ieee_define_named_type (info, tag, nt->type.indx, size, TRUE,
		5901	localp, &strdef)
		5902	\|\| ! ieee_write_number (info, structp ? 'S' : 'U')
		5903	\|\| ! ieee_write_number (info, size))
		5904	return FALSE;
		5905
		5906	if (! ignorep)
		5907	{
		5908	const char *hold;
		5909
		5910	/* We never want nt->type.name to be NULL. We want the rest of
		5911	the type to be the object set up on the type stack; it will
		5912	have a NULL name if tag is NULL. */
		5913	hold = nt->type.name;
		5914	nt->type = info->type_stack->type;
		5915	nt->type.name = hold;
		5916	}
		5917
		5918	info->type_stack->type.name = tag;
		5919	info->type_stack->type.strdef = strdef;
		5920	info->type_stack->type.ignorep = ignorep;
		5921
		5922	return TRUE;
		5923	}
		5924
		5925	/* Add a field to a struct. */
		5926
		5927	static bfd_boolean
		5928	ieee_struct_field (void p, const char name, bfd_vma bitpos, bfd_vma bitsize,
		5929	enum debug_visibility visibility)
		5930	{
		5931	struct ieee_handle info = (struct ieee_handle ) p;
		5932	unsigned int size;
		5933	bfd_boolean unsignedp;
		5934	bfd_boolean referencep;
		5935	bfd_boolean localp;
		5936	unsigned int indx;
		5937	bfd_vma offset;
		5938
		5939	assert (info->type_stack != NULL
		5940	&& info->type_stack->next != NULL
		5941	&& ! ieee_buffer_emptyp (&info->type_stack->next->type.strdef));
		5942
		5943	/* If we are ignoring this struct definition, just pop and ignore
		5944	the type. */
		5945	if (info->type_stack->next->type.ignorep)
		5946	{
		5947	ieee_pop_unused_type (info);
		5948	return TRUE;
		5949	}
		5950
		5951	size = info->type_stack->type.size;
		5952	unsignedp = info->type_stack->type.unsignedp;
		5953	referencep = info->type_stack->type.referencep;
		5954	localp = info->type_stack->type.localp;
		5955	indx = ieee_pop_type (info);
		5956
		5957	if (localp)
		5958	info->type_stack->type.localp = TRUE;
		5959
		5960	if (info->type_stack->type.classdef != NULL)
		5961	{
		5962	unsigned int flags;
		5963	unsigned int nindx;
		5964
		5965	/* This is a class. We must add a description of this field to
		5966	the class records we are building. */
		5967
		5968	flags = ieee_vis_to_flags (visibility);
		5969	nindx = info->type_stack->type.classdef->indx;
		5970	if (! ieee_change_buffer (info,
		5971	&info->type_stack->type.classdef->pmiscbuf)
		5972	\|\| ! ieee_write_asn (info, nindx, 'd')
		5973	\|\| ! ieee_write_asn (info, nindx, flags)
		5974	\|\| ! ieee_write_atn65 (info, nindx, name)
		5975	\|\| ! ieee_write_atn65 (info, nindx, name))
		5976	return FALSE;
		5977	info->type_stack->type.classdef->pmisccount += 4;
		5978
		5979	if (referencep)
		5980	{
		5981	/* We need to output a record recording that this field is
		5982	really of reference type. We put this on the refs field
		5983	of classdef, so that it can be appended to the C++
		5984	records after the class is defined. */
		5985
		5986	nindx = info->name_indx;
		5987	++info->name_indx;
		5988
		5989	if (! ieee_change_buffer (info,
		5990	&info->type_stack->type.classdef->refs)
		5991	\|\| ! ieee_write_byte (info, (int) ieee_nn_record)
		5992	\|\| ! ieee_write_number (info, nindx)
		5993	\|\| ! ieee_write_id (info, "")
		5994	\|\| ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
		5995	\|\| ! ieee_write_number (info, nindx)
		5996	\|\| ! ieee_write_number (info, 0)
		5997	\|\| ! ieee_write_number (info, 62)
		5998	\|\| ! ieee_write_number (info, 80)
		5999	\|\| ! ieee_write_number (info, 4)
		6000	\|\| ! ieee_write_asn (info, nindx, 'R')
		6001	\|\| ! ieee_write_asn (info, nindx, 3)
		6002	\|\| ! ieee_write_atn65 (info, nindx, info->type_stack->type.name)
		6003	\|\| ! ieee_write_atn65 (info, nindx, name))
		6004	return FALSE;
		6005	}
		6006	}
		6007
		6008	/* If the bitsize doesn't match the expected size, we need to output
		6009	a bitfield type. */
		6010	if (size == 0 \|\| bitsize == 0 \|\| bitsize == size * 8)
		6011	offset = bitpos / 8;
		6012	else
		6013	{
		6014	if (! ieee_define_type (info, 0, unsignedp,
		6015	info->type_stack->type.localp)
		6016	\|\| ! ieee_write_number (info, 'g')
		6017	\|\| ! ieee_write_number (info, unsignedp ? 0 : 1)
		6018	\|\| ! ieee_write_number (info, bitsize)
		6019	\|\| ! ieee_write_number (info, indx))
		6020	return FALSE;
		6021	indx = ieee_pop_type (info);
		6022	offset = bitpos;
		6023	}
		6024
		6025	/* Switch to the struct we are building in order to output this
		6026	field definition. */
		6027	return (ieee_change_buffer (info, &info->type_stack->type.strdef)
		6028	&& ieee_write_id (info, name)
		6029	&& ieee_write_number (info, indx)
		6030	&& ieee_write_number (info, offset));
		6031	}
		6032
		6033	/* Finish up a struct type. */
		6034
		6035	static bfd_boolean
		6036	ieee_end_struct_type (void *p)
		6037	{
		6038	struct ieee_handle info = (struct ieee_handle ) p;
		6039	struct ieee_buflist *pb;
		6040
		6041	assert (info->type_stack != NULL
		6042	&& ! ieee_buffer_emptyp (&info->type_stack->type.strdef));
		6043
		6044	/* If we were ignoring this struct definition because it was a
		6045	duplicate definition, just through away whatever bytes we have
		6046	accumulated. Leave the type on the stack. */
		6047	if (info->type_stack->type.ignorep)
		6048	return TRUE;
		6049
		6050	/* If this is not a duplicate definition of this tag, then localp
		6051	will be FALSE, and we can put it in the global type block.
		6052	FIXME: We should avoid outputting duplicate definitions which are
		6053	the same. */
		6054	if (! info->type_stack->type.localp)
		6055	{
		6056	/* Make sure we have started the global type block. */
		6057	if (ieee_buffer_emptyp (&info->global_types))
		6058	{
		6059	if (! ieee_change_buffer (info, &info->global_types)
		6060	\|\| ! ieee_write_byte (info, (int) ieee_bb_record_enum)
		6061	\|\| ! ieee_write_byte (info, 2)
		6062	\|\| ! ieee_write_number (info, 0)
		6063	\|\| ! ieee_write_id (info, ""))
		6064	return FALSE;
		6065	}
		6066	pb = &info->global_types;
		6067	}
		6068	else
		6069	{
		6070	/* Make sure we have started the types block. */
		6071	if (ieee_buffer_emptyp (&info->types))
		6072	{
		6073	if (! ieee_change_buffer (info, &info->types)
		6074	\|\| ! ieee_write_byte (info, (int) ieee_bb_record_enum)
		6075	\|\| ! ieee_write_byte (info, 1)
		6076	\|\| ! ieee_write_number (info, 0)
		6077	\|\| ! ieee_write_id (info, info->modname))
		6078	return FALSE;
		6079	}
		6080	pb = &info->types;
		6081	}
		6082
		6083	/* Append the struct definition to the types. */
		6084	if (! ieee_append_buffer (info, pb, &info->type_stack->type.strdef)
		6085	\|\| ! ieee_init_buffer (info, &info->type_stack->type.strdef))
		6086	return FALSE;
		6087
		6088	/* Leave the struct on the type stack. */
		6089
		6090	return TRUE;
		6091	}
		6092
		6093	/* Start a class type. */
		6094
		6095	static bfd_boolean
		6096	ieee_start_class_type (void p, const char tag, unsigned int id,
		6097	bfd_boolean structp, unsigned int size,
		6098	bfd_boolean vptr, bfd_boolean ownvptr)
		6099	{
		6100	struct ieee_handle info = (struct ieee_handle ) p;
		6101	const char *vclass;
		6102	struct ieee_buflist pmiscbuf;
		6103	unsigned int indx;
		6104	struct ieee_type_class *classdef;
		6105
		6106	/* A C++ class is output as a C++ struct along with a set of pmisc
		6107	records describing the class. */
		6108
		6109	/* We need to have a name so that we can associate the struct and
		6110	the class. */
		6111	if (tag == NULL)
		6112	{
		6113	char *t;
		6114
		6115	t = (char *) xmalloc (20);
		6116	sprintf (t, "__anon%u", id);
		6117	tag = t;
		6118	}
		6119
		6120	/* We can't write out the virtual table information until we have
		6121	finished the class, because we don't know the virtual table size.
		6122	We get the size from the largest voffset we see. */
		6123	vclass = NULL;
		6124	if (vptr && ! ownvptr)
		6125	{
		6126	vclass = info->type_stack->type.name;
		6127	assert (vclass != NULL);
		6128	/* We don't call ieee_pop_unused_type, since the class should
		6129	get defined. */
		6130	(void) ieee_pop_type (info);
		6131	}
		6132
		6133	if (! ieee_start_struct_type (p, tag, id, structp, size))
		6134	return FALSE;
		6135
		6136	indx = info->name_indx;
		6137	++info->name_indx;
		6138
		6139	/* We write out pmisc records into the classdef field. We will
		6140	write out the pmisc start after we know the number of records we
		6141	need. */
		6142	if (! ieee_init_buffer (info, &pmiscbuf)
		6143	\|\| ! ieee_change_buffer (info, &pmiscbuf)
		6144	\|\| ! ieee_write_asn (info, indx, 'T')
		6145	\|\| ! ieee_write_asn (info, indx, structp ? 'o' : 'u')
		6146	\|\| ! ieee_write_atn65 (info, indx, tag))
		6147	return FALSE;
		6148
		6149	classdef = (struct ieee_type_class ) xmalloc (sizeof classdef);
		6150	memset (classdef, 0, sizeof *classdef);
		6151
		6152	classdef->indx = indx;
		6153	classdef->pmiscbuf = pmiscbuf;
		6154	classdef->pmisccount = 3;
		6155	classdef->vclass = vclass;
		6156	classdef->ownvptr = ownvptr;
		6157
		6158	info->type_stack->type.classdef = classdef;
		6159
		6160	return TRUE;
		6161	}
		6162
		6163	/* Add a static member to a class. */
		6164
		6165	static bfd_boolean
		6166	ieee_class_static_member (void p, const char name, const char *physname,
		6167	enum debug_visibility visibility)
		6168	{
		6169	struct ieee_handle info = (struct ieee_handle ) p;
		6170	unsigned int flags;
		6171	unsigned int nindx;
		6172
		6173	/* We don't care about the type. Hopefully there will be a call to
		6174	ieee_variable declaring the physical name and the type, since
		6175	that is where an IEEE consumer must get the type. */
		6176	ieee_pop_unused_type (info);
		6177
		6178	assert (info->type_stack != NULL
		6179	&& info->type_stack->type.classdef != NULL);
		6180
		6181	flags = ieee_vis_to_flags (visibility);
		6182	flags \|= CXXFLAGS_STATIC;
		6183
		6184	nindx = info->type_stack->type.classdef->indx;
		6185
		6186	if (! ieee_change_buffer (info, &info->type_stack->type.classdef->pmiscbuf)
		6187	\|\| ! ieee_write_asn (info, nindx, 'd')
		6188	\|\| ! ieee_write_asn (info, nindx, flags)
		6189	\|\| ! ieee_write_atn65 (info, nindx, name)
		6190	\|\| ! ieee_write_atn65 (info, nindx, physname))
		6191	return FALSE;
		6192	info->type_stack->type.classdef->pmisccount += 4;
		6193
		6194	return TRUE;
		6195	}
		6196
		6197	/* Add a base class to a class. */
		6198
		6199	static bfd_boolean
		6200	ieee_class_baseclass (void *p, bfd_vma bitpos, bfd_boolean is_virtual,
		6201	enum debug_visibility visibility)
		6202	{
		6203	struct ieee_handle info = (struct ieee_handle ) p;
		6204	const char *bname;
		6205	bfd_boolean localp;
		6206	unsigned int bindx;
		6207	char *fname;
		6208	unsigned int flags;
		6209	unsigned int nindx;
		6210
		6211	assert (info->type_stack != NULL
		6212	&& info->type_stack->type.name != NULL
		6213	&& info->type_stack->next != NULL
		6214	&& info->type_stack->next->type.classdef != NULL
		6215	&& ! ieee_buffer_emptyp (&info->type_stack->next->type.strdef));
		6216
		6217	bname = info->type_stack->type.name;
		6218	localp = info->type_stack->type.localp;
		6219	bindx = ieee_pop_type (info);
		6220
		6221	/* We are currently defining both a struct and a class. We must
		6222	write out a field definition in the struct which holds the base
		6223	class. The stabs debugging reader will create a field named
		6224	_vb$CLASS for a virtual base class, so we just use that. FIXME:
		6225	we should not depend upon a detail of stabs debugging. */
		6226	if (is_virtual)
		6227	{
		6228	fname = (char *) xmalloc (strlen (bname) + sizeof "_vb$");
		6229	sprintf (fname, "_vb$%s", bname);
		6230	flags = BASEFLAGS_VIRTUAL;
		6231	}
		6232	else
		6233	{
		6234	if (localp)
		6235	info->type_stack->type.localp = TRUE;
		6236
		6237	fname = (char *) xmalloc (strlen (bname) + sizeof "_b$");
		6238	sprintf (fname, "_b$%s", bname);
		6239
		6240	if (! ieee_change_buffer (info, &info->type_stack->type.strdef)
		6241	\|\| ! ieee_write_id (info, fname)
		6242	\|\| ! ieee_write_number (info, bindx)
		6243	\|\| ! ieee_write_number (info, bitpos / 8))
		6244	{
		6245	free (fname);
		6246	return FALSE;
		6247	}
		6248	flags = 0;
		6249	}
		6250
		6251	if (visibility == DEBUG_VISIBILITY_PRIVATE)
		6252	flags \|= BASEFLAGS_PRIVATE;
		6253
		6254	nindx = info->type_stack->type.classdef->indx;
		6255
		6256	if (! ieee_change_buffer (info, &info->type_stack->type.classdef->pmiscbuf)
		6257	\|\| ! ieee_write_asn (info, nindx, 'b')
		6258	\|\| ! ieee_write_asn (info, nindx, flags)
		6259	\|\| ! ieee_write_atn65 (info, nindx, bname)
		6260	\|\| ! ieee_write_asn (info, nindx, 0)
		6261	\|\| ! ieee_write_atn65 (info, nindx, fname))
		6262	{
		6263	free (fname);
		6264	return FALSE;
		6265	}
		6266	info->type_stack->type.classdef->pmisccount += 5;
		6267
		6268	free (fname);
		6269
		6270	return TRUE;
		6271	}
		6272
		6273	/* Start building a method for a class. */
		6274
		6275	static bfd_boolean
		6276	ieee_class_start_method (void p, const char name)
		6277	{
		6278	struct ieee_handle info = (struct ieee_handle ) p;
		6279
		6280	assert (info->type_stack != NULL
		6281	&& info->type_stack->type.classdef != NULL
		6282	&& info->type_stack->type.classdef->method == NULL);
		6283
		6284	info->type_stack->type.classdef->method = name;
		6285
		6286	return TRUE;
		6287	}
		6288
		6289	/* Define a new method variant, either static or not. */
		6290
		6291	static bfd_boolean
		6292	ieee_class_method_var (struct ieee_handle info, const char physname,
		6293	enum debug_visibility visibility,
		6294	bfd_boolean staticp, bfd_boolean constp,
		6295	bfd_boolean volatilep, bfd_vma voffset,
		6296	bfd_boolean context)
		6297	{
		6298	unsigned int flags;
		6299	unsigned int nindx;
		6300	bfd_boolean is_virtual;
		6301
		6302	/* We don't need the type of the method. An IEEE consumer which
		6303	wants the type must track down the function by the physical name
		6304	and get the type from that. */
		6305	ieee_pop_unused_type (info);
		6306
		6307	/* We don't use the context. FIXME: We probably ought to use it to
		6308	adjust the voffset somehow, but I don't really know how. */
		6309	if (context)
		6310	ieee_pop_unused_type (info);
		6311
		6312	assert (info->type_stack != NULL
		6313	&& info->type_stack->type.classdef != NULL
		6314	&& info->type_stack->type.classdef->method != NULL);
		6315
		6316	flags = ieee_vis_to_flags (visibility);
		6317
		6318	/* FIXME: We never set CXXFLAGS_OVERRIDE, CXXFLAGS_OPERATOR,
		6319	CXXFLAGS_CTORDTOR, CXXFLAGS_CTOR, or CXXFLAGS_INLINE. */
		6320
		6321	if (staticp)
		6322	flags \|= CXXFLAGS_STATIC;
		6323	if (constp)
		6324	flags \|= CXXFLAGS_CONST;
		6325	if (volatilep)
		6326	flags \|= CXXFLAGS_VOLATILE;
		6327
		6328	nindx = info->type_stack->type.classdef->indx;
		6329
		6330	is_virtual = context \|\| voffset > 0;
		6331
		6332	if (! ieee_change_buffer (info,
		6333	&info->type_stack->type.classdef->pmiscbuf)
		6334	\|\| ! ieee_write_asn (info, nindx, is_virtual ? 'v' : 'm')
		6335	\|\| ! ieee_write_asn (info, nindx, flags)
		6336	\|\| ! ieee_write_atn65 (info, nindx,
		6337	info->type_stack->type.classdef->method)
		6338	\|\| ! ieee_write_atn65 (info, nindx, physname))
		6339	return FALSE;
		6340
		6341	if (is_virtual)
		6342	{
		6343	if (voffset > info->type_stack->type.classdef->voffset)
		6344	info->type_stack->type.classdef->voffset = voffset;
		6345	if (! ieee_write_asn (info, nindx, voffset))
		6346	return FALSE;
		6347	++info->type_stack->type.classdef->pmisccount;
		6348	}
		6349
		6350	if (! ieee_write_asn (info, nindx, 0))
		6351	return FALSE;
		6352
		6353	info->type_stack->type.classdef->pmisccount += 5;
		6354
		6355	return TRUE;
		6356	}
		6357
		6358	/* Define a new method variant. */
		6359
		6360	static bfd_boolean
		6361	ieee_class_method_variant (void p, const char physname,
		6362	enum debug_visibility visibility,
		6363	bfd_boolean constp, bfd_boolean volatilep,
		6364	bfd_vma voffset, bfd_boolean context)
		6365	{
		6366	struct ieee_handle info = (struct ieee_handle ) p;
		6367
		6368	return ieee_class_method_var (info, physname, visibility, FALSE, constp,
		6369	volatilep, voffset, context);
		6370	}
		6371
		6372	/* Define a new static method variant. */
		6373
		6374	static bfd_boolean
		6375	ieee_class_static_method_variant (void p, const char physname,
		6376	enum debug_visibility visibility,
		6377	bfd_boolean constp, bfd_boolean volatilep)
		6378	{
		6379	struct ieee_handle info = (struct ieee_handle ) p;
		6380
		6381	return ieee_class_method_var (info, physname, visibility, TRUE, constp,
		6382	volatilep, 0, FALSE);
		6383	}
		6384
		6385	/* Finish up a method. */
		6386
		6387	static bfd_boolean
		6388	ieee_class_end_method (void *p)
		6389	{
		6390	struct ieee_handle info = (struct ieee_handle ) p;
		6391
		6392	assert (info->type_stack != NULL
		6393	&& info->type_stack->type.classdef != NULL
		6394	&& info->type_stack->type.classdef->method != NULL);
		6395
		6396	info->type_stack->type.classdef->method = NULL;
		6397
		6398	return TRUE;
		6399	}
		6400
		6401	/* Finish up a class. */
		6402
		6403	static bfd_boolean
		6404	ieee_end_class_type (void *p)
		6405	{
		6406	struct ieee_handle info = (struct ieee_handle ) p;
		6407	unsigned int nindx;
		6408
		6409	assert (info->type_stack != NULL
		6410	&& info->type_stack->type.classdef != NULL);
		6411
		6412	/* If we were ignoring this class definition because it was a
		6413	duplicate definition, just through away whatever bytes we have
		6414	accumulated. Leave the type on the stack. */
		6415	if (info->type_stack->type.ignorep)
		6416	return TRUE;
		6417
		6418	nindx = info->type_stack->type.classdef->indx;
		6419
		6420	/* If we have a virtual table, we can write out the information now. */
		6421	if (info->type_stack->type.classdef->vclass != NULL
		6422	\|\| info->type_stack->type.classdef->ownvptr)
		6423	{
		6424	if (! ieee_change_buffer (info,
		6425	&info->type_stack->type.classdef->pmiscbuf)
		6426	\|\| ! ieee_write_asn (info, nindx, 'z')
		6427	\|\| ! ieee_write_atn65 (info, nindx, "")
		6428	\|\| ! ieee_write_asn (info, nindx,
		6429	info->type_stack->type.classdef->voffset))
		6430	return FALSE;
		6431	if (info->type_stack->type.classdef->ownvptr)
		6432	{
		6433	if (! ieee_write_atn65 (info, nindx, ""))
		6434	return FALSE;
		6435	}
		6436	else
		6437	{
		6438	if (! ieee_write_atn65 (info, nindx,
		6439	info->type_stack->type.classdef->vclass))
		6440	return FALSE;
		6441	}
		6442	if (! ieee_write_asn (info, nindx, 0))
		6443	return FALSE;
		6444	info->type_stack->type.classdef->pmisccount += 5;
		6445	}
		6446
		6447	/* Now that we know the number of pmisc records, we can write out
		6448	the atn62 which starts the pmisc records, and append them to the
		6449	C++ buffers. */
		6450
		6451	if (! ieee_change_buffer (info, &info->cxx)
		6452	\|\| ! ieee_write_byte (info, (int) ieee_nn_record)
		6453	\|\| ! ieee_write_number (info, nindx)
		6454	\|\| ! ieee_write_id (info, "")
		6455	\|\| ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
		6456	\|\| ! ieee_write_number (info, nindx)
		6457	\|\| ! ieee_write_number (info, 0)
		6458	\|\| ! ieee_write_number (info, 62)
		6459	\|\| ! ieee_write_number (info, 80)
		6460	\|\| ! ieee_write_number (info,
		6461	info->type_stack->type.classdef->pmisccount))
		6462	return FALSE;
		6463
		6464	if (! ieee_append_buffer (info, &info->cxx,
		6465	&info->type_stack->type.classdef->pmiscbuf))
		6466	return FALSE;
		6467	if (! ieee_buffer_emptyp (&info->type_stack->type.classdef->refs))
		6468	{
		6469	if (! ieee_append_buffer (info, &info->cxx,
		6470	&info->type_stack->type.classdef->refs))
		6471	return FALSE;
		6472	}
		6473
		6474	return ieee_end_struct_type (p);
		6475	}
		6476
		6477	/* Push a previously seen typedef onto the type stack. */
		6478
		6479	static bfd_boolean
		6480	ieee_typedef_type (void p, const char name)
		6481	{
		6482	struct ieee_handle info = (struct ieee_handle ) p;
		6483	struct ieee_name_type_hash_entry *h;
		6484	struct ieee_name_type *nt;
		6485
		6486	h = ieee_name_type_hash_lookup (&info->typedefs, name, FALSE, FALSE);
		6487
		6488	/* h should never be NULL, since that would imply that the generic
		6489	debugging code has asked for a typedef which it has not yet
		6490	defined. */
		6491	assert (h != NULL);
		6492
		6493	/* We always use the most recently defined type for this name, which
		6494	will be the first one on the list. */
		6495
		6496	nt = h->types;
		6497	if (! ieee_push_type (info, nt->type.indx, nt->type.size,
		6498	nt->type.unsignedp, nt->type.localp))
		6499	return FALSE;
		6500
		6501	/* Copy over any other type information we may have. */
		6502	info->type_stack->type = nt->type;
		6503
		6504	return TRUE;
		6505	}
		6506
		6507	/* Push a tagged type onto the type stack. */
		6508
		6509	static bfd_boolean
		6510	ieee_tag_type (void p, const char name, unsigned int id,
		6511	enum debug_type_kind kind)
		6512	{
		6513	struct ieee_handle info = (struct ieee_handle ) p;
		6514	bfd_boolean localp;
		6515	bfd_boolean copy;
		6516	char ab[20];
		6517	struct ieee_name_type_hash_entry *h;
		6518	struct ieee_name_type *nt;
		6519
		6520	if (kind == DEBUG_KIND_ENUM)
		6521	{
		6522	struct ieee_defined_enum *e;
		6523
		6524	if (name == NULL)
		6525	abort ();
		6526	for (e = info->enums; e != NULL; e = e->next)
		6527	if (e->tag != NULL && strcmp (e->tag, name) == 0)
		6528	return ieee_push_type (info, e->indx, 0, TRUE, FALSE);
		6529
		6530	e = (struct ieee_defined_enum ) xmalloc (sizeof e);
		6531	memset (e, 0, sizeof *e);
		6532
		6533	e->indx = info->type_indx;
		6534	++info->type_indx;
		6535	e->tag = name;
		6536	e->defined = FALSE;
		6537
		6538	e->next = info->enums;
		6539	info->enums = e;
		6540
		6541	return ieee_push_type (info, e->indx, 0, TRUE, FALSE);
		6542	}
		6543
		6544	localp = FALSE;
		6545
		6546	copy = FALSE;
		6547	if (name == NULL)
		6548	{
		6549	sprintf (ab, "__anon%u", id);
		6550	name = ab;
		6551	copy = TRUE;
		6552	}
		6553
		6554	h = ieee_name_type_hash_lookup (&info->tags, name, TRUE, copy);
		6555	if (h == NULL)
		6556	return FALSE;
		6557
		6558	for (nt = h->types; nt != NULL; nt = nt->next)
		6559	{
		6560	if (nt->id == id)
		6561	{
		6562	if (! ieee_push_type (info, nt->type.indx, nt->type.size,
		6563	nt->type.unsignedp, nt->type.localp))
		6564	return FALSE;
		6565	/* Copy over any other type information we may have. */
		6566	info->type_stack->type = nt->type;
		6567	return TRUE;
		6568	}
		6569
		6570	if (! nt->type.localp)
		6571	{
		6572	/* This is a duplicate of a global type, so it must be
		6573	local. */
		6574	localp = TRUE;
		6575	}
		6576	}
		6577
		6578	nt = (struct ieee_name_type ) xmalloc (sizeof nt);
		6579	memset (nt, 0, sizeof *nt);
		6580
		6581	nt->id = id;
		6582	nt->type.name = h->root.string;
		6583	nt->type.indx = info->type_indx;
		6584	nt->type.localp = localp;
		6585	++info->type_indx;
		6586	nt->kind = kind;
		6587
		6588	nt->next = h->types;
		6589	h->types = nt;
		6590
		6591	if (! ieee_push_type (info, nt->type.indx, 0, FALSE, localp))
		6592	return FALSE;
		6593
		6594	info->type_stack->type.name = h->root.string;
		6595
		6596	return TRUE;
		6597	}
		6598
		6599	/* Output a typedef. */
		6600
		6601	static bfd_boolean
		6602	ieee_typdef (void p, const char name)
		6603	{
		6604	struct ieee_handle info = (struct ieee_handle ) p;
		6605	struct ieee_write_type type;
		6606	unsigned int indx;
		6607	bfd_boolean found;
		6608	bfd_boolean localp;
		6609	struct ieee_name_type_hash_entry *h;
		6610	struct ieee_name_type *nt;
		6611
		6612	type = info->type_stack->type;
		6613	indx = type.indx;
		6614
		6615	/* If this is a simple builtin type using a builtin name, we don't
		6616	want to output the typedef itself. We also want to change the
		6617	type index to correspond to the name being used. We recognize
		6618	names used in stabs debugging output even if they don't exactly
		6619	correspond to the names used for the IEEE builtin types. */
		6620	found = FALSE;
		6621	if (indx <= (unsigned int) builtin_bcd_float)
		6622	{
		6623	switch ((enum builtin_types) indx)
		6624	{
		6625	default:
		6626	break;
		6627
		6628	case builtin_void:
		6629	if (strcmp (name, "void") == 0)
		6630	found = TRUE;
		6631	break;
		6632
		6633	case builtin_signed_char:
		6634	case builtin_char:
		6635	if (strcmp (name, "signed char") == 0)
		6636	{
		6637	indx = (unsigned int) builtin_signed_char;
		6638	found = TRUE;
		6639	}
		6640	else if (strcmp (name, "char") == 0)
		6641	{
		6642	indx = (unsigned int) builtin_char;
		6643	found = TRUE;
		6644	}
		6645	break;
		6646
		6647	case builtin_unsigned_char:
		6648	if (strcmp (name, "unsigned char") == 0)
		6649	found = TRUE;
		6650	break;
		6651
		6652	case builtin_signed_short_int:
		6653	case builtin_short:
		6654	case builtin_short_int:
		6655	case builtin_signed_short:
		6656	if (strcmp (name, "signed short int") == 0)
		6657	{
		6658	indx = (unsigned int) builtin_signed_short_int;
		6659	found = TRUE;
		6660	}
		6661	else if (strcmp (name, "short") == 0)
		6662	{
		6663	indx = (unsigned int) builtin_short;
		6664	found = TRUE;
		6665	}
		6666	else if (strcmp (name, "short int") == 0)
		6667	{
		6668	indx = (unsigned int) builtin_short_int;
		6669	found = TRUE;
		6670	}
		6671	else if (strcmp (name, "signed short") == 0)
		6672	{
		6673	indx = (unsigned int) builtin_signed_short;
		6674	found = TRUE;
		6675	}
		6676	break;
		6677
		6678	case builtin_unsigned_short_int:
		6679	case builtin_unsigned_short:
		6680	if (strcmp (name, "unsigned short int") == 0
		6681	\|\| strcmp (name, "short unsigned int") == 0)
		6682	{
		6683	indx = builtin_unsigned_short_int;
		6684	found = TRUE;
		6685	}
		6686	else if (strcmp (name, "unsigned short") == 0)
		6687	{
		6688	indx = builtin_unsigned_short;
		6689	found = TRUE;
		6690	}
		6691	break;
		6692
		6693	case builtin_signed_long:
		6694	case builtin_int: /* FIXME: Size depends upon architecture. */
		6695	case builtin_long:
		6696	if (strcmp (name, "signed long") == 0)
		6697	{
		6698	indx = builtin_signed_long;
		6699	found = TRUE;
		6700	}
		6701	else if (strcmp (name, "int") == 0)
		6702	{
		6703	indx = builtin_int;
		6704	found = TRUE;
		6705	}
		6706	else if (strcmp (name, "long") == 0
		6707	\|\| strcmp (name, "long int") == 0)
		6708	{
		6709	indx = builtin_long;
		6710	found = TRUE;
		6711	}
		6712	break;
		6713
		6714	case builtin_unsigned_long:
		6715	case builtin_unsigned: /* FIXME: Size depends upon architecture. */
		6716	case builtin_unsigned_int: /* FIXME: Like builtin_unsigned. */
		6717	if (strcmp (name, "unsigned long") == 0
		6718	\|\| strcmp (name, "long unsigned int") == 0)
		6719	{
		6720	indx = builtin_unsigned_long;
		6721	found = TRUE;
		6722	}
		6723	else if (strcmp (name, "unsigned") == 0)
		6724	{
		6725	indx = builtin_unsigned;
		6726	found = TRUE;
		6727	}
		6728	else if (strcmp (name, "unsigned int") == 0)
		6729	{
		6730	indx = builtin_unsigned_int;
		6731	found = TRUE;
		6732	}
		6733	break;
		6734
		6735	case builtin_signed_long_long:
		6736	if (strcmp (name, "signed long long") == 0
		6737	\|\| strcmp (name, "long long int") == 0)
		6738	found = TRUE;
		6739	break;
		6740
		6741	case builtin_unsigned_long_long:
		6742	if (strcmp (name, "unsigned long long") == 0
		6743	\|\| strcmp (name, "long long unsigned int") == 0)
		6744	found = TRUE;
		6745	break;
		6746
		6747	case builtin_float:
		6748	if (strcmp (name, "float") == 0)
		6749	found = TRUE;
		6750	break;
		6751
		6752	case builtin_double:
		6753	if (strcmp (name, "double") == 0)
		6754	found = TRUE;
		6755	break;
		6756
		6757	case builtin_long_double:
		6758	if (strcmp (name, "long double") == 0)
		6759	found = TRUE;
		6760	break;
		6761
		6762	case builtin_long_long_double:
		6763	if (strcmp (name, "long long double") == 0)
		6764	found = TRUE;
		6765	break;
		6766	}
		6767
		6768	if (found)
		6769	type.indx = indx;
		6770	}
		6771
		6772	h = ieee_name_type_hash_lookup (&info->typedefs, name, TRUE, FALSE);
		6773	if (h == NULL)
		6774	return FALSE;
		6775
		6776	/* See if we have already defined this type with this name. */
		6777	localp = type.localp;
		6778	for (nt = h->types; nt != NULL; nt = nt->next)
		6779	{
		6780	if (nt->id == indx)
		6781	{
		6782	/* If this is a global definition, then we don't need to
		6783	do anything here. */
		6784	if (! nt->type.localp)
		6785	{
		6786	ieee_pop_unused_type (info);
		6787	return TRUE;
		6788	}
		6789	}
		6790	else
		6791	{
		6792	/* This is a duplicate definition, so make this one local. */
		6793	localp = TRUE;
		6794	}
		6795	}
		6796
		6797	/* We need to add a new typedef for this type. */
		6798
		6799	nt = (struct ieee_name_type ) xmalloc (sizeof nt);
		6800	memset (nt, 0, sizeof *nt);
		6801	nt->id = indx;
		6802	nt->type = type;
		6803	nt->type.name = name;
		6804	nt->type.localp = localp;
		6805	nt->kind = DEBUG_KIND_ILLEGAL;
		6806
		6807	nt->next = h->types;
		6808	h->types = nt;
		6809
		6810	if (found)
		6811	{
		6812	/* This is one of the builtin typedefs, so we don't need to
		6813	actually define it. */
		6814	ieee_pop_unused_type (info);
		6815	return TRUE;
		6816	}
		6817
		6818	indx = ieee_pop_type (info);
		6819
		6820	if (! ieee_define_named_type (info, name, (unsigned int) -1, type.size,
		6821	type.unsignedp, localp,
		6822	(struct ieee_buflist *) NULL)
		6823	\|\| ! ieee_write_number (info, 'T')
		6824	\|\| ! ieee_write_number (info, indx))
		6825	return FALSE;
		6826
		6827	/* Remove the type we just added to the type stack. This should not
		6828	be ieee_pop_unused_type, since the type is used, we just don't
		6829	need it now. */
		6830	(void) ieee_pop_type (info);
		6831
		6832	return TRUE;
		6833	}
		6834
		6835	/* Output a tag for a type. We don't have to do anything here. */
		6836
		6837	static bfd_boolean
		6838	ieee_tag (void p, const char name ATTRIBUTE_UNUSED)
		6839	{
		6840	struct ieee_handle info = (struct ieee_handle ) p;
		6841
		6842	/* This should not be ieee_pop_unused_type, since we want the type
		6843	to be defined. */
		6844	(void) ieee_pop_type (info);
		6845	return TRUE;
		6846	}
		6847
		6848	/* Output an integer constant. */
		6849
		6850	static bfd_boolean
		6851	ieee_int_constant (void p ATTRIBUTE_UNUSED, const char name ATTRIBUTE_UNUSED,
		6852	bfd_vma val ATTRIBUTE_UNUSED)
		6853	{
		6854	/* FIXME. */
		6855	return TRUE;
		6856	}
		6857
		6858	/* Output a floating point constant. */
		6859
		6860	static bfd_boolean
		6861	ieee_float_constant (void *p ATTRIBUTE_UNUSED,
		6862	const char *name ATTRIBUTE_UNUSED,
		6863	double val ATTRIBUTE_UNUSED)
		6864	{
		6865	/* FIXME. */
		6866	return TRUE;
		6867	}
		6868
		6869	/* Output a typed constant. */
		6870
		6871	static bfd_boolean
		6872	ieee_typed_constant (void p, const char name ATTRIBUTE_UNUSED,
		6873	bfd_vma val ATTRIBUTE_UNUSED)
		6874	{
		6875	struct ieee_handle info = (struct ieee_handle ) p;
		6876
		6877	/* FIXME. */
		6878	ieee_pop_unused_type (info);
		6879	return TRUE;
		6880	}
		6881
		6882	/* Output a variable. */
		6883
		6884	static bfd_boolean
		6885	ieee_variable (void p, const char name, enum debug_var_kind kind,
		6886	bfd_vma val)
		6887	{
		6888	struct ieee_handle info = (struct ieee_handle ) p;
		6889	unsigned int name_indx;
		6890	unsigned int size;
		6891	bfd_boolean referencep;
		6892	unsigned int type_indx;
		6893	bfd_boolean asn;
		6894	int refflag;
		6895
		6896	size = info->type_stack->type.size;
		6897	referencep = info->type_stack->type.referencep;
		6898	type_indx = ieee_pop_type (info);
		6899
		6900	assert (! ieee_buffer_emptyp (&info->vars));
		6901	if (! ieee_change_buffer (info, &info->vars))
		6902	return FALSE;
		6903
		6904	name_indx = info->name_indx;
		6905	++info->name_indx;
		6906
		6907	/* Write out an NN and an ATN record for this variable. */
		6908	if (! ieee_write_byte (info, (int) ieee_nn_record)
		6909	\|\| ! ieee_write_number (info, name_indx)
		6910	\|\| ! ieee_write_id (info, name)
		6911	\|\| ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
		6912	\|\| ! ieee_write_number (info, name_indx)
		6913	\|\| ! ieee_write_number (info, type_indx))
		6914	return FALSE;
		6915	switch (kind)
		6916	{
		6917	default:
		6918	abort ();
		6919	return FALSE;
		6920	case DEBUG_GLOBAL:
		6921	if (! ieee_write_number (info, 8)
		6922	\|\| ! ieee_add_range (info, FALSE, val, val + size))
		6923	return FALSE;
		6924	refflag = 0;
		6925	asn = TRUE;
		6926	break;
		6927	case DEBUG_STATIC:
		6928	if (! ieee_write_number (info, 3)
		6929	\|\| ! ieee_add_range (info, FALSE, val, val + size))
		6930	return FALSE;
		6931	refflag = 1;
		6932	asn = TRUE;
		6933	break;
		6934	case DEBUG_LOCAL_STATIC:
		6935	if (! ieee_write_number (info, 3)
		6936	\|\| ! ieee_add_range (info, FALSE, val, val + size))
		6937	return FALSE;
		6938	refflag = 2;
		6939	asn = TRUE;
		6940	break;
		6941	case DEBUG_LOCAL:
		6942	if (! ieee_write_number (info, 1)
		6943	\|\| ! ieee_write_number (info, val))
		6944	return FALSE;
		6945	refflag = 2;
		6946	asn = FALSE;
		6947	break;
		6948	case DEBUG_REGISTER:
		6949	if (! ieee_write_number (info, 2)
		6950	\|\| ! ieee_write_number (info,
		6951	ieee_genreg_to_regno (info->abfd, val)))
		6952	return FALSE;
		6953	refflag = 2;
		6954	asn = FALSE;
		6955	break;
		6956	}
		6957
		6958	if (asn)
		6959	{
		6960	if (! ieee_write_asn (info, name_indx, val))
		6961	return FALSE;
		6962	}
		6963
		6964	/* If this is really a reference type, then we just output it with
		6965	pointer type, and must now output a C++ record indicating that it
		6966	is really reference type. */
		6967	if (referencep)
		6968	{
		6969	unsigned int nindx;
		6970
		6971	nindx = info->name_indx;
		6972	++info->name_indx;
		6973
		6974	/* If this is a global variable, we want to output the misc
		6975	record in the C++ misc record block. Otherwise, we want to
		6976	output it just after the variable definition, which is where
		6977	the current buffer is. */
		6978	if (refflag != 2)
		6979	{
		6980	if (! ieee_change_buffer (info, &info->cxx))
		6981	return FALSE;
		6982	}
		6983
		6984	if (! ieee_write_byte (info, (int) ieee_nn_record)
		6985	\|\| ! ieee_write_number (info, nindx)
		6986	\|\| ! ieee_write_id (info, "")
		6987	\|\| ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
		6988	\|\| ! ieee_write_number (info, nindx)
		6989	\|\| ! ieee_write_number (info, 0)
		6990	\|\| ! ieee_write_number (info, 62)
		6991	\|\| ! ieee_write_number (info, 80)
		6992	\|\| ! ieee_write_number (info, 3)
		6993	\|\| ! ieee_write_asn (info, nindx, 'R')
		6994	\|\| ! ieee_write_asn (info, nindx, refflag)
		6995	\|\| ! ieee_write_atn65 (info, nindx, name))
		6996	return FALSE;
		6997	}
		6998
		6999	return TRUE;
		7000	}
		7001
		7002	/* Start outputting information for a function. */
		7003
		7004	static bfd_boolean
		7005	ieee_start_function (void p, const char name, bfd_boolean global)
		7006	{
		7007	struct ieee_handle info = (struct ieee_handle ) p;
		7008	bfd_boolean referencep;
		7009	unsigned int retindx, typeindx;
		7010
		7011	referencep = info->type_stack->type.referencep;
		7012	retindx = ieee_pop_type (info);
		7013
		7014	/* Besides recording a BB4 or BB6 block, we record the type of the
		7015	function in the BB1 typedef block. We can't write out the full
		7016	type until we have seen all the parameters, so we accumulate it
		7017	in info->fntype and info->fnargs. */
		7018	if (! ieee_buffer_emptyp (&info->fntype))
		7019	{
		7020	/* FIXME: This might happen someday if we support nested
		7021	functions. */
		7022	abort ();
		7023	}
		7024
		7025	info->fnname = name;
		7026
		7027	/* An attribute of 0x40 means that the push mask is unknown. */
		7028	if (! ieee_define_named_type (info, name, (unsigned int) -1, 0, FALSE, TRUE,
		7029	&info->fntype)
		7030	\|\| ! ieee_write_number (info, 'x')
		7031	\|\| ! ieee_write_number (info, 0x40)
		7032	\|\| ! ieee_write_number (info, 0)
		7033	\|\| ! ieee_write_number (info, 0)
		7034	\|\| ! ieee_write_number (info, retindx))
		7035	return FALSE;
		7036
		7037	typeindx = ieee_pop_type (info);
		7038
		7039	if (! ieee_init_buffer (info, &info->fnargs))
		7040	return FALSE;
		7041	info->fnargcount = 0;
		7042
		7043	/* If the function return value is actually a reference type, we
		7044	must add a record indicating that. */
		7045	if (referencep)
		7046	{
		7047	unsigned int nindx;
		7048
		7049	nindx = info->name_indx;
		7050	++info->name_indx;
		7051	if (! ieee_change_buffer (info, &info->cxx)
		7052	\|\| ! ieee_write_byte (info, (int) ieee_nn_record)
		7053	\|\| ! ieee_write_number (info, nindx)
		7054	\|\| ! ieee_write_id (info, "")
		7055	\|\| ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
		7056	\|\| ! ieee_write_number (info, nindx)
		7057	\|\| ! ieee_write_number (info, 0)
		7058	\|\| ! ieee_write_number (info, 62)
		7059	\|\| ! ieee_write_number (info, 80)
		7060	\|\| ! ieee_write_number (info, 3)
		7061	\|\| ! ieee_write_asn (info, nindx, 'R')
		7062	\|\| ! ieee_write_asn (info, nindx, global ? 0 : 1)
		7063	\|\| ! ieee_write_atn65 (info, nindx, name))
		7064	return FALSE;
		7065	}
		7066
		7067	assert (! ieee_buffer_emptyp (&info->vars));
		7068	if (! ieee_change_buffer (info, &info->vars))
		7069	return FALSE;
		7070
		7071	/* The address is written out as the first block. */
		7072
		7073	++info->block_depth;
		7074
		7075	return (ieee_write_byte (info, (int) ieee_bb_record_enum)
		7076	&& ieee_write_byte (info, global ? 4 : 6)
		7077	&& ieee_write_number (info, 0)
		7078	&& ieee_write_id (info, name)
		7079	&& ieee_write_number (info, 0)
		7080	&& ieee_write_number (info, typeindx));
		7081	}
		7082
		7083	/* Add a function parameter. This will normally be called before the
		7084	first block, so we postpone them until we see the block. */
		7085
		7086	static bfd_boolean
		7087	ieee_function_parameter (void p, const char name, enum debug_parm_kind kind,
		7088	bfd_vma val)
		7089	{
		7090	struct ieee_handle info = (struct ieee_handle ) p;
		7091	struct ieee_pending_parm m, *pm;
		7092
		7093	assert (info->block_depth == 1);
		7094
		7095	m = (struct ieee_pending_parm ) xmalloc (sizeof m);
		7096	memset (m, 0, sizeof *m);
		7097
		7098	m->next = NULL;
		7099	m->name = name;
		7100	m->referencep = info->type_stack->type.referencep;
		7101	m->type = ieee_pop_type (info);
		7102	m->kind = kind;
		7103	m->val = val;
		7104
		7105	for (pm = &info->pending_parms; pm != NULL; pm = &(pm)->next)
		7106	;
		7107	*pm = m;
		7108
		7109	/* Add the type to the fnargs list. */
		7110	if (! ieee_change_buffer (info, &info->fnargs)
		7111	\|\| ! ieee_write_number (info, m->type))
		7112	return FALSE;
		7113	++info->fnargcount;
		7114
		7115	return TRUE;
		7116	}
		7117
		7118	/* Output pending function parameters. */
		7119
		7120	static bfd_boolean
		7121	ieee_output_pending_parms (struct ieee_handle *info)
		7122	{
		7123	struct ieee_pending_parm *m;
		7124	unsigned int refcount;
		7125
		7126	refcount = 0;
		7127	for (m = info->pending_parms; m != NULL; m = m->next)
		7128	{
		7129	enum debug_var_kind vkind;
		7130
		7131	switch (m->kind)
		7132	{
		7133	default:
		7134	abort ();
		7135	return FALSE;
		7136	case DEBUG_PARM_STACK:
		7137	case DEBUG_PARM_REFERENCE:
		7138	vkind = DEBUG_LOCAL;
		7139	break;
		7140	case DEBUG_PARM_REG:
		7141	case DEBUG_PARM_REF_REG:
		7142	vkind = DEBUG_REGISTER;
		7143	break;
		7144	}
		7145
		7146	if (! ieee_push_type (info, m->type, 0, FALSE, FALSE))
		7147	return FALSE;
		7148	info->type_stack->type.referencep = m->referencep;
		7149	if (m->referencep)
		7150	++refcount;
		7151	if (! ieee_variable ((void *) info, m->name, vkind, m->val))
		7152	return FALSE;
		7153	}
		7154
		7155	/* If there are any reference parameters, we need to output a
		7156	miscellaneous record indicating them. */
		7157	if (refcount > 0)
		7158	{
		7159	unsigned int nindx, varindx;
		7160
		7161	/* FIXME: The MRI compiler outputs the demangled function name
		7162	here, but we are outputting the mangled name. */
		7163	nindx = info->name_indx;
		7164	++info->name_indx;
		7165	if (! ieee_change_buffer (info, &info->vars)
		7166	\|\| ! ieee_write_byte (info, (int) ieee_nn_record)
		7167	\|\| ! ieee_write_number (info, nindx)
		7168	\|\| ! ieee_write_id (info, "")
		7169	\|\| ! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
		7170	\|\| ! ieee_write_number (info, nindx)
		7171	\|\| ! ieee_write_number (info, 0)
		7172	\|\| ! ieee_write_number (info, 62)
		7173	\|\| ! ieee_write_number (info, 80)
		7174	\|\| ! ieee_write_number (info, refcount + 3)
		7175	\|\| ! ieee_write_asn (info, nindx, 'B')
		7176	\|\| ! ieee_write_atn65 (info, nindx, info->fnname)
		7177	\|\| ! ieee_write_asn (info, nindx, 0))
		7178	return FALSE;
		7179	for (m = info->pending_parms, varindx = 1;
		7180	m != NULL;
		7181	m = m->next, varindx++)
		7182	{
		7183	if (m->referencep)
		7184	{
		7185	if (! ieee_write_asn (info, nindx, varindx))
		7186	return FALSE;
		7187	}
		7188	}
		7189	}
		7190
		7191	m = info->pending_parms;
		7192	while (m != NULL)
		7193	{
		7194	struct ieee_pending_parm *next;
		7195
		7196	next = m->next;
		7197	free (m);
		7198	m = next;
		7199	}
		7200
		7201	info->pending_parms = NULL;
		7202
		7203	return TRUE;
		7204	}
		7205
		7206	/* Start a block. If this is the first block, we output the address
		7207	to finish the BB4 or BB6, and then output the function parameters. */
		7208
		7209	static bfd_boolean
		7210	ieee_start_block (void *p, bfd_vma addr)
		7211	{
		7212	struct ieee_handle info = (struct ieee_handle ) p;
		7213
		7214	if (! ieee_change_buffer (info, &info->vars))
		7215	return FALSE;
		7216
		7217	if (info->block_depth == 1)
		7218	{
		7219	if (! ieee_write_number (info, addr)
		7220	\|\| ! ieee_output_pending_parms (info))
		7221	return FALSE;
		7222	}
		7223	else
		7224	{
		7225	if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
		7226	\|\| ! ieee_write_byte (info, 6)
		7227	\|\| ! ieee_write_number (info, 0)
		7228	\|\| ! ieee_write_id (info, "")
		7229	\|\| ! ieee_write_number (info, 0)
		7230	\|\| ! ieee_write_number (info, 0)
		7231	\|\| ! ieee_write_number (info, addr))
		7232	return FALSE;
		7233	}
		7234
		7235	if (! ieee_start_range (info, addr))
		7236	return FALSE;
		7237
		7238	++info->block_depth;
		7239
		7240	return TRUE;
		7241	}
		7242
		7243	/* End a block. */
		7244
		7245	static bfd_boolean
		7246	ieee_end_block (void *p, bfd_vma addr)
		7247	{
		7248	struct ieee_handle info = (struct ieee_handle ) p;
		7249
		7250	/* The address we are given is the end of the block, but IEEE seems
		7251	to want to the address of the last byte in the block, so we
		7252	subtract one. */
		7253	if (! ieee_change_buffer (info, &info->vars)
		7254	\|\| ! ieee_write_byte (info, (int) ieee_be_record_enum)
		7255	\|\| ! ieee_write_number (info, addr - 1))
		7256	return FALSE;
		7257
		7258	if (! ieee_end_range (info, addr))
		7259	return FALSE;
		7260
		7261	--info->block_depth;
		7262
		7263	if (addr > info->highaddr)
		7264	info->highaddr = addr;
		7265
		7266	return TRUE;
		7267	}
		7268
		7269	/* End a function. */
		7270
		7271	static bfd_boolean
		7272	ieee_end_function (void *p)
		7273	{
		7274	struct ieee_handle info = (struct ieee_handle ) p;
		7275
		7276	assert (info->block_depth == 1);
		7277
		7278	--info->block_depth;
		7279
		7280	/* Now we can finish up fntype, and add it to the typdef section.
		7281	At this point, fntype is the 'x' type up to the argument count,
		7282	and fnargs is the argument types. We must add the argument
		7283	count, and we must add the level. FIXME: We don't record varargs
		7284	functions correctly. In fact, stabs debugging does not give us
		7285	enough information to do so. */
		7286	if (! ieee_change_buffer (info, &info->fntype)
		7287	\|\| ! ieee_write_number (info, info->fnargcount)
		7288	\|\| ! ieee_change_buffer (info, &info->fnargs)
		7289	\|\| ! ieee_write_number (info, 0))
		7290	return FALSE;
		7291
		7292	/* Make sure the typdef block has been started. */
		7293	if (ieee_buffer_emptyp (&info->types))
		7294	{
		7295	if (! ieee_change_buffer (info, &info->types)
		7296	\|\| ! ieee_write_byte (info, (int) ieee_bb_record_enum)
		7297	\|\| ! ieee_write_byte (info, 1)
		7298	\|\| ! ieee_write_number (info, 0)
		7299	\|\| ! ieee_write_id (info, info->modname))
		7300	return FALSE;
		7301	}
		7302
		7303	if (! ieee_append_buffer (info, &info->types, &info->fntype)
		7304	\|\| ! ieee_append_buffer (info, &info->types, &info->fnargs))
		7305	return FALSE;
		7306
		7307	info->fnname = NULL;
		7308	if (! ieee_init_buffer (info, &info->fntype)
		7309	\|\| ! ieee_init_buffer (info, &info->fnargs))
		7310	return FALSE;
		7311	info->fnargcount = 0;
		7312
		7313	return TRUE;
		7314	}
		7315
		7316	/* Record line number information. */
		7317
		7318	static bfd_boolean
		7319	ieee_lineno (void p, const char filename, unsigned long lineno, bfd_vma addr)
		7320	{
		7321	struct ieee_handle info = (struct ieee_handle ) p;
		7322
		7323	assert (info->filename != NULL);
		7324
		7325	/* The HP simulator seems to get confused when more than one line is
		7326	listed for the same address, at least if they are in different
		7327	files. We handle this by always listing the last line for a
		7328	given address, since that seems to be the one that gdb uses. */
		7329	if (info->pending_lineno_filename != NULL
		7330	&& addr != info->pending_lineno_addr)
		7331	{
		7332	/* Make sure we have a line number block. */
		7333	if (! ieee_buffer_emptyp (&info->linenos))
		7334	{
		7335	if (! ieee_change_buffer (info, &info->linenos))
		7336	return FALSE;
		7337	}
		7338	else
		7339	{
		7340	info->lineno_name_indx = info->name_indx;
		7341	++info->name_indx;
		7342	if (! ieee_change_buffer (info, &info->linenos)
		7343	\|\| ! ieee_write_byte (info, (int) ieee_bb_record_enum)
		7344	\|\| ! ieee_write_byte (info, 5)
		7345	\|\| ! ieee_write_number (info, 0)
		7346	\|\| ! ieee_write_id (info, info->filename)
		7347	\|\| ! ieee_write_byte (info, (int) ieee_nn_record)
		7348	\|\| ! ieee_write_number (info, info->lineno_name_indx)
		7349	\|\| ! ieee_write_id (info, ""))
		7350	return FALSE;
		7351	info->lineno_filename = info->filename;
		7352	}
		7353
		7354	if (filename_cmp (info->pending_lineno_filename,
		7355	info->lineno_filename) != 0)
		7356	{
		7357	if (filename_cmp (info->filename, info->lineno_filename) != 0)
		7358	{
		7359	/* We were not in the main file. Close the block for the
		7360	included file. */
		7361	if (! ieee_write_byte (info, (int) ieee_be_record_enum))
		7362	return FALSE;
		7363	if (filename_cmp (info->filename,
		7364	info->pending_lineno_filename) == 0)
		7365	{
		7366	/* We need a new NN record, and we aren't about to
		7367	output one. */
		7368	info->lineno_name_indx = info->name_indx;
		7369	++info->name_indx;
		7370	if (! ieee_write_byte (info, (int) ieee_nn_record)
		7371	\|\| ! ieee_write_number (info, info->lineno_name_indx)
		7372	\|\| ! ieee_write_id (info, ""))
		7373	return FALSE;
		7374	}
		7375	}
		7376	if (filename_cmp (info->filename,
		7377	info->pending_lineno_filename) != 0)
		7378	{
		7379	/* We are not changing to the main file. Open a block for
		7380	the new included file. */
		7381	info->lineno_name_indx = info->name_indx;
		7382	++info->name_indx;
		7383	if (! ieee_write_byte (info, (int) ieee_bb_record_enum)
		7384	\|\| ! ieee_write_byte (info, 5)
		7385	\|\| ! ieee_write_number (info, 0)
		7386	\|\| ! ieee_write_id (info, info->pending_lineno_filename)
		7387	\|\| ! ieee_write_byte (info, (int) ieee_nn_record)
		7388	\|\| ! ieee_write_number (info, info->lineno_name_indx)
		7389	\|\| ! ieee_write_id (info, ""))
		7390	return FALSE;
		7391	}
		7392	info->lineno_filename = info->pending_lineno_filename;
		7393	}
		7394
		7395	if (! ieee_write_2bytes (info, (int) ieee_atn_record_enum)
		7396	\|\| ! ieee_write_number (info, info->lineno_name_indx)
		7397	\|\| ! ieee_write_number (info, 0)
		7398	\|\| ! ieee_write_number (info, 7)
		7399	\|\| ! ieee_write_number (info, info->pending_lineno)
		7400	\|\| ! ieee_write_number (info, 0)
		7401	\|\| ! ieee_write_asn (info, info->lineno_name_indx,
		7402	info->pending_lineno_addr))
		7403	return FALSE;
		7404	}
		7405
		7406	info->pending_lineno_filename = filename;
		7407	info->pending_lineno = lineno;
		7408	info->pending_lineno_addr = addr;
		7409
		7410	return TRUE;
		7411	}

Subversion Repositories Kolibri OS

(root)/contrib/toolchain/binutils/binutils/ieee.c @ 6324 – Rev 5217