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

Rev	Author	Line No.	Line
5217	serge	1	/* debug.c -- Handle generic debugging information.
6324	serge	2	Copyright (C) 1995-2015 Free Software Foundation, Inc.
5217	serge	3	Written by Ian Lance Taylor .
		4
		5	This file is part of GNU Binutils.
		6
		7	This program is free software; you can redistribute it and/or modify
		8	it under the terms of the GNU General Public License as published by
		9	the Free Software Foundation; either version 3 of the License, or
		10	(at your option) any later version.
		11
		12	This program is distributed in the hope that it will be useful,
		13	but WITHOUT ANY WARRANTY; without even the implied warranty of
		14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		15	GNU General Public License for more details.
		16
		17	You should have received a copy of the GNU General Public License
		18	along with this program; if not, write to the Free Software
		19	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
		20	02110-1301, USA. */
		21
		22
		23	/* This file implements a generic debugging format. We may eventually
		24	have readers which convert different formats into this generic
		25	format, and writers which write it out. The initial impetus for
		26	this was writing a converter from stabs to HP IEEE-695 debugging
		27	format. */
		28
		29	#include "sysdep.h"
		30	#include
		31	#include "bfd.h"
		32	#include "libiberty.h"
		33	#include "filenames.h"
		34	#include "debug.h"
		35
		36	/* Global information we keep for debugging. A pointer to this
		37	structure is the debugging handle passed to all the routines. */
		38
		39	struct debug_handle
		40	{
		41	/* A linked list of compilation units. */
		42	struct debug_unit *units;
		43	/* The current compilation unit. */
		44	struct debug_unit *current_unit;
		45	/* The current source file. */
		46	struct debug_file *current_file;
		47	/* The current function. */
		48	struct debug_function *current_function;
		49	/* The current block. */
		50	struct debug_block *current_block;
		51	/* The current line number information for the current unit. */
		52	struct debug_lineno *current_lineno;
		53	/* Mark. This is used by debug_write. */
		54	unsigned int mark;
		55	/* A struct/class ID used by debug_write. */
		56	unsigned int class_id;
		57	/* The base for class_id for this call to debug_write. */
		58	unsigned int base_id;
		59	/* The current line number in debug_write. */
		60	struct debug_lineno *current_write_lineno;
		61	unsigned int current_write_lineno_index;
		62	/* A list of classes which have assigned ID's during debug_write.
		63	This is linked through the next_id field of debug_class_type. */
		64	struct debug_class_id *id_list;
		65	/* A list used to avoid recursion during debug_type_samep. */
		66	struct debug_type_compare_list *compare_list;
		67	};
		68
		69	/* Information we keep for a single compilation unit. */
		70
		71	struct debug_unit
		72	{
		73	/* The next compilation unit. */
		74	struct debug_unit *next;
		75	/* A list of files included in this compilation unit. The first
		76	file is always the main one, and that is where the main file name
		77	is stored. */
		78	struct debug_file *files;
		79	/* Line number information for this compilation unit. This is not
		80	stored by function, because assembler code may have line number
		81	information without function information. */
		82	struct debug_lineno *linenos;
		83	};
		84
		85	/* Information kept for a single source file. */
		86
		87	struct debug_file
		88	{
		89	/* The next source file in this compilation unit. */
		90	struct debug_file *next;
		91	/* The name of the source file. */
		92	const char *filename;
		93	/* Global functions, variables, types, etc. */
		94	struct debug_namespace *globals;
		95	};
		96
		97	/* A type. */
		98
		99	struct debug_type_s
		100	{
		101	/* Kind of type. */
		102	enum debug_type_kind kind;
		103	/* Size of type (0 if not known). */
		104	unsigned int size;
		105	/* Type which is a pointer to this type. */
		106	debug_type pointer;
		107	/* Tagged union with additional information about the type. */
		108	union
		109	{
		110	/* DEBUG_KIND_INDIRECT. */
		111	struct debug_indirect_type *kindirect;
		112	/* DEBUG_KIND_INT. */
		113	/* Whether the integer is unsigned. */
		114	bfd_boolean kint;
		115	/* DEBUG_KIND_STRUCT, DEBUG_KIND_UNION, DEBUG_KIND_CLASS,
		116	DEBUG_KIND_UNION_CLASS. */
		117	struct debug_class_type *kclass;
		118	/* DEBUG_KIND_ENUM. */
		119	struct debug_enum_type *kenum;
		120	/* DEBUG_KIND_POINTER. */
		121	struct debug_type_s *kpointer;
		122	/* DEBUG_KIND_FUNCTION. */
		123	struct debug_function_type *kfunction;
		124	/* DEBUG_KIND_REFERENCE. */
		125	struct debug_type_s *kreference;
		126	/* DEBUG_KIND_RANGE. */
		127	struct debug_range_type *krange;
		128	/* DEBUG_KIND_ARRAY. */
		129	struct debug_array_type *karray;
		130	/* DEBUG_KIND_SET. */
		131	struct debug_set_type *kset;
		132	/* DEBUG_KIND_OFFSET. */
		133	struct debug_offset_type *koffset;
		134	/* DEBUG_KIND_METHOD. */
		135	struct debug_method_type *kmethod;
		136	/* DEBUG_KIND_CONST. */
		137	struct debug_type_s *kconst;
		138	/* DEBUG_KIND_VOLATILE. */
		139	struct debug_type_s *kvolatile;
		140	/* DEBUG_KIND_NAMED, DEBUG_KIND_TAGGED. */
		141	struct debug_named_type *knamed;
		142	} u;
		143	};
		144
		145	/* Information kept for an indirect type. */
		146
		147	struct debug_indirect_type
		148	{
		149	/* Slot where the final type will appear. */
		150	debug_type *slot;
		151	/* Tag. */
		152	const char *tag;
		153	};
		154
		155	/* Information kept for a struct, union, or class. */
		156
		157	struct debug_class_type
		158	{
		159	/* NULL terminated array of fields. */
		160	debug_field *fields;
		161	/* A mark field which indicates whether the struct has already been
		162	printed. */
		163	unsigned int mark;
		164	/* This is used to uniquely identify unnamed structs when printing. */
		165	unsigned int id;
		166	/* The remaining fields are only used for DEBUG_KIND_CLASS and
		167	DEBUG_KIND_UNION_CLASS. */
		168	/* NULL terminated array of base classes. */
		169	debug_baseclass *baseclasses;
		170	/* NULL terminated array of methods. */
		171	debug_method *methods;
		172	/* The type of the class providing the virtual function table for
		173	this class. This may point to the type itself. */
		174	debug_type vptrbase;
		175	};
		176
		177	/* Information kept for an enum. */
		178
		179	struct debug_enum_type
		180	{
		181	/* NULL terminated array of names. */
		182	const char **names;
		183	/* Array of corresponding values. */
		184	bfd_signed_vma *values;
		185	};
		186
		187	/* Information kept for a function. FIXME: We should be able to
		188	record the parameter types. */
		189
		190	struct debug_function_type
		191	{
		192	/* Return type. */
		193	debug_type return_type;
		194	/* NULL terminated array of argument types. */
		195	debug_type *arg_types;
		196	/* Whether the function takes a variable number of arguments. */
		197	bfd_boolean varargs;
		198	};
		199
		200	/* Information kept for a range. */
		201
		202	struct debug_range_type
		203	{
		204	/* Range base type. */
		205	debug_type type;
		206	/* Lower bound. */
		207	bfd_signed_vma lower;
		208	/* Upper bound. */
		209	bfd_signed_vma upper;
		210	};
		211
		212	/* Information kept for an array. */
		213
		214	struct debug_array_type
		215	{
		216	/* Element type. */
		217	debug_type element_type;
		218	/* Range type. */
		219	debug_type range_type;
		220	/* Lower bound. */
		221	bfd_signed_vma lower;
		222	/* Upper bound. */
		223	bfd_signed_vma upper;
		224	/* Whether this array is really a string. */
		225	bfd_boolean stringp;
		226	};
		227
		228	/* Information kept for a set. */
		229
		230	struct debug_set_type
		231	{
		232	/* Base type. */
		233	debug_type type;
		234	/* Whether this set is really a bitstring. */
		235	bfd_boolean bitstringp;
		236	};
		237
		238	/* Information kept for an offset type (a based pointer). */
		239
		240	struct debug_offset_type
		241	{
		242	/* The type the pointer is an offset from. */
		243	debug_type base_type;
		244	/* The type the pointer points to. */
		245	debug_type target_type;
		246	};
		247
		248	/* Information kept for a method type. */
		249
		250	struct debug_method_type
		251	{
		252	/* The return type. */
		253	debug_type return_type;
		254	/* The object type which this method is for. */
		255	debug_type domain_type;
		256	/* A NULL terminated array of argument types. */
		257	debug_type *arg_types;
		258	/* Whether the method takes a variable number of arguments. */
		259	bfd_boolean varargs;
		260	};
		261
		262	/* Information kept for a named type. */
		263
		264	struct debug_named_type
		265	{
		266	/* Name. */
		267	struct debug_name *name;
		268	/* Real type. */
		269	debug_type type;
		270	};
		271
		272	/* A field in a struct or union. */
		273
		274	struct debug_field_s
		275	{
		276	/* Name of the field. */
		277	const char *name;
		278	/* Type of the field. */
		279	struct debug_type_s *type;
		280	/* Visibility of the field. */
		281	enum debug_visibility visibility;
		282	/* Whether this is a static member. */
		283	bfd_boolean static_member;
		284	union
		285	{
		286	/* If static_member is false. */
		287	struct
		288	{
		289	/* Bit position of the field in the struct. */
		290	unsigned int bitpos;
		291	/* Size of the field in bits. */
		292	unsigned int bitsize;
		293	} f;
		294	/* If static_member is true. */
		295	struct
		296	{
		297	const char *physname;
		298	} s;
		299	} u;
		300	};
		301
		302	/* A base class for an object. */
		303
		304	struct debug_baseclass_s
		305	{
		306	/* Type of the base class. */
		307	struct debug_type_s *type;
		308	/* Bit position of the base class in the object. */
		309	unsigned int bitpos;
		310	/* Whether the base class is virtual. */
		311	bfd_boolean is_virtual;
		312	/* Visibility of the base class. */
		313	enum debug_visibility visibility;
		314	};
		315
		316	/* A method of an object. */
		317
		318	struct debug_method_s
		319	{
		320	/* The name of the method. */
		321	const char *name;
		322	/* A NULL terminated array of different types of variants. */
		323	struct debug_method_variant_s **variants;
		324	};
		325
		326	/* The variants of a method function of an object. These indicate
		327	which method to run. */
		328
		329	struct debug_method_variant_s
		330	{
		331	/* The physical name of the function. */
		332	const char *physname;
		333	/* The type of the function. */
		334	struct debug_type_s *type;
		335	/* The visibility of the function. */
		336	enum debug_visibility visibility;
		337	/* Whether the function is const. */
		338	bfd_boolean constp;
		339	/* Whether the function is volatile. */
		340	bfd_boolean volatilep;
		341	/* The offset to the function in the virtual function table. */
		342	bfd_vma voffset;
		343	/* If voffset is VOFFSET_STATIC_METHOD, this is a static method. */
		344	#define VOFFSET_STATIC_METHOD ((bfd_vma) -1)
		345	/* Context of a virtual method function. */
		346	struct debug_type_s *context;
		347	};
		348
		349	/* A variable. This is the information we keep for a variable object.
		350	This has no name; a name is associated with a variable in a
		351	debug_name structure. */
		352
		353	struct debug_variable
		354	{
		355	/* Kind of variable. */
		356	enum debug_var_kind kind;
		357	/* Type. */
		358	debug_type type;
		359	/* Value. The interpretation of the value depends upon kind. */
		360	bfd_vma val;
		361	};
		362
		363	/* A function. This has no name; a name is associated with a function
		364	in a debug_name structure. */
		365
		366	struct debug_function
		367	{
		368	/* Return type. */
		369	debug_type return_type;
		370	/* Parameter information. */
		371	struct debug_parameter *parameters;
		372	/* Block information. The first structure on the list is the main
		373	block of the function, and describes function local variables. */
		374	struct debug_block *blocks;
		375	};
		376
		377	/* A function parameter. */
		378
		379	struct debug_parameter
		380	{
		381	/* Next parameter. */
		382	struct debug_parameter *next;
		383	/* Name. */
		384	const char *name;
		385	/* Type. */
		386	debug_type type;
		387	/* Kind. */
		388	enum debug_parm_kind kind;
		389	/* Value (meaning depends upon kind). */
		390	bfd_vma val;
		391	};
		392
		393	/* A typed constant. */
		394
		395	struct debug_typed_constant
		396	{
		397	/* Type. */
		398	debug_type type;
		399	/* Value. FIXME: We may eventually need to support non-integral
		400	values. */
		401	bfd_vma val;
		402	};
		403
		404	/* Information about a block within a function. */
		405
		406	struct debug_block
		407	{
		408	/* Next block with the same parent. */
		409	struct debug_block *next;
		410	/* Parent block. */
		411	struct debug_block *parent;
		412	/* List of child blocks. */
		413	struct debug_block *children;
		414	/* Start address of the block. */
		415	bfd_vma start;
		416	/* End address of the block. */
		417	bfd_vma end;
		418	/* Local variables. */
		419	struct debug_namespace *locals;
		420	};
		421
		422	/* Line number information we keep for a compilation unit. FIXME:
		423	This structure is easy to create, but can be very space
		424	inefficient. */
		425
		426	struct debug_lineno
		427	{
		428	/* More line number information for this block. */
		429	struct debug_lineno *next;
		430	/* Source file. */
		431	struct debug_file *file;
		432	/* Line numbers, terminated by a -1 or the end of the array. */
		433	#define DEBUG_LINENO_COUNT 10
		434	unsigned long linenos[DEBUG_LINENO_COUNT];
		435	/* Addresses for the line numbers. */
		436	bfd_vma addrs[DEBUG_LINENO_COUNT];
		437	};
		438
		439	/* A namespace. This is a mapping from names to objects. FIXME: This
		440	should be implemented as a hash table. */
		441
		442	struct debug_namespace
		443	{
		444	/* List of items in this namespace. */
		445	struct debug_name *list;
		446	/* Pointer to where the next item in this namespace should go. */
		447	struct debug_name **tail;
		448	};
		449
		450	/* Kinds of objects that appear in a namespace. */
		451
		452	enum debug_object_kind
		453	{
		454	/* A type. */
		455	DEBUG_OBJECT_TYPE,
		456	/* A tagged type (really a different sort of namespace). */
		457	DEBUG_OBJECT_TAG,
		458	/* A variable. */
		459	DEBUG_OBJECT_VARIABLE,
		460	/* A function. */
		461	DEBUG_OBJECT_FUNCTION,
		462	/* An integer constant. */
		463	DEBUG_OBJECT_INT_CONSTANT,
		464	/* A floating point constant. */
		465	DEBUG_OBJECT_FLOAT_CONSTANT,
		466	/* A typed constant. */
		467	DEBUG_OBJECT_TYPED_CONSTANT
		468	};
		469
		470	/* Linkage of an object that appears in a namespace. */
		471
		472	enum debug_object_linkage
		473	{
		474	/* Local variable. */
		475	DEBUG_LINKAGE_AUTOMATIC,
		476	/* Static--either file static or function static, depending upon the
		477	namespace is. */
		478	DEBUG_LINKAGE_STATIC,
		479	/* Global. */
		480	DEBUG_LINKAGE_GLOBAL,
		481	/* No linkage. */
		482	DEBUG_LINKAGE_NONE
		483	};
		484
		485	/* A name in a namespace. */
		486
		487	struct debug_name
		488	{
		489	/* Next name in this namespace. */
		490	struct debug_name *next;
		491	/* Name. */
		492	const char *name;
		493	/* Mark. This is used by debug_write. */
		494	unsigned int mark;
		495	/* Kind of object. */
		496	enum debug_object_kind kind;
		497	/* Linkage of object. */
		498	enum debug_object_linkage linkage;
		499	/* Tagged union with additional information about the object. */
		500	union
		501	{
		502	/* DEBUG_OBJECT_TYPE. */
		503	struct debug_type_s *type;
		504	/* DEBUG_OBJECT_TAG. */
		505	struct debug_type_s *tag;
		506	/* DEBUG_OBJECT_VARIABLE. */
		507	struct debug_variable *variable;
		508	/* DEBUG_OBJECT_FUNCTION. */
		509	struct debug_function *function;
		510	/* DEBUG_OBJECT_INT_CONSTANT. */
		511	bfd_vma int_constant;
		512	/* DEBUG_OBJECT_FLOAT_CONSTANT. */
		513	double float_constant;
		514	/* DEBUG_OBJECT_TYPED_CONSTANT. */
		515	struct debug_typed_constant *typed_constant;
		516	} u;
		517	};
		518
		519	/* During debug_write, a linked list of these structures is used to
		520	keep track of ID numbers that have been assigned to classes. */
		521
		522	struct debug_class_id
		523	{
		524	/* Next ID number. */
		525	struct debug_class_id *next;
		526	/* The type with the ID. */
		527	struct debug_type_s *type;
		528	/* The tag; NULL if no tag. */
		529	const char *tag;
		530	};
		531
		532	/* During debug_type_samep, a linked list of these structures is kept
		533	on the stack to avoid infinite recursion. */
		534
		535	struct debug_type_compare_list
		536	{
		537	/* Next type on list. */
		538	struct debug_type_compare_list *next;
		539	/* The types we are comparing. */
		540	struct debug_type_s *t1;
		541	struct debug_type_s *t2;
		542	};
		543
		544	/* During debug_get_real_type, a linked list of these structures is
		545	kept on the stack to avoid infinite recursion. */
		546
		547	struct debug_type_real_list
		548	{
		549	/* Next type on list. */
		550	struct debug_type_real_list *next;
		551	/* The type we are checking. */
		552	struct debug_type_s *t;
		553	};
		554
		555	/* Local functions. */
		556
		557	static void debug_error (const char *);
		558	static struct debug_name *debug_add_to_namespace
		559	(struct debug_handle , struct debug_namespace , const char ,
		560	enum debug_object_kind, enum debug_object_linkage);
		561	static struct debug_name *debug_add_to_current_namespace
		562	(struct debug_handle , const char , enum debug_object_kind,
		563	enum debug_object_linkage);
		564	static struct debug_type_s *debug_make_type
		565	(struct debug_handle *, enum debug_type_kind, unsigned int);
		566	static struct debug_type_s *debug_get_real_type
		567	(void , debug_type, struct debug_type_real_list );
		568	static bfd_boolean debug_write_name
		569	(struct debug_handle , const struct debug_write_fns , void *,
		570	struct debug_name *);
		571	static bfd_boolean debug_write_type
		572	(struct debug_handle , const struct debug_write_fns , void *,
		573	struct debug_type_s , struct debug_name );
		574	static bfd_boolean debug_write_class_type
		575	(struct debug_handle , const struct debug_write_fns , void *,
		576	struct debug_type_s , const char );
		577	static bfd_boolean debug_write_function
		578	(struct debug_handle , const struct debug_write_fns , void *,
		579	const char , enum debug_object_linkage, struct debug_function );
		580	static bfd_boolean debug_write_block
		581	(struct debug_handle , const struct debug_write_fns , void *,
		582	struct debug_block *);
		583	static bfd_boolean debug_write_linenos
		584	(struct debug_handle , const struct debug_write_fns , void *, bfd_vma);
		585	static bfd_boolean debug_set_class_id
		586	(struct debug_handle , const char , struct debug_type_s *);
		587	static bfd_boolean debug_type_samep
		588	(struct debug_handle , struct debug_type_s , struct debug_type_s *);
		589	static bfd_boolean debug_class_type_samep
		590	(struct debug_handle , struct debug_type_s , struct debug_type_s *);
		591
		592	/* Issue an error message. */
		593
		594	static void
		595	debug_error (const char *message)
		596	{
		597	fprintf (stderr, "%s\n", message);
		598	}
		599
		600	/* Add an object to a namespace. */
		601
		602	static struct debug_name *
		603	debug_add_to_namespace (struct debug_handle *info ATTRIBUTE_UNUSED,
		604	struct debug_namespace *nsp, const char name,
		605	enum debug_object_kind kind,
		606	enum debug_object_linkage linkage)
		607	{
		608	struct debug_name *n;
		609	struct debug_namespace *ns;
		610
		611	n = (struct debug_name ) xmalloc (sizeof n);
		612	memset (n, 0, sizeof *n);
		613
		614	n->name = name;
		615	n->kind = kind;
		616	n->linkage = linkage;
		617
		618	ns = *nsp;
		619	if (ns == NULL)
		620	{
		621	ns = (struct debug_namespace ) xmalloc (sizeof ns);
		622	memset (ns, 0, sizeof *ns);
		623
		624	ns->tail = &ns->list;
		625
		626	*nsp = ns;
		627	}
		628
		629	*ns->tail = n;
		630	ns->tail = &n->next;
		631
		632	return n;
		633	}
		634
		635	/* Add an object to the current namespace. */
		636
		637	static struct debug_name *
		638	debug_add_to_current_namespace (struct debug_handle info, const char name,
		639	enum debug_object_kind kind,
		640	enum debug_object_linkage linkage)
		641	{
		642	struct debug_namespace **nsp;
		643
		644	if (info->current_unit == NULL
		645	\|\| info->current_file == NULL)
		646	{
		647	debug_error (_("debug_add_to_current_namespace: no current file"));
		648	return NULL;
		649	}
		650
		651	if (info->current_block != NULL)
		652	nsp = &info->current_block->locals;
		653	else
		654	nsp = &info->current_file->globals;
		655
		656	return debug_add_to_namespace (info, nsp, name, kind, linkage);
		657	}
		658
		659	/* Return a handle for debugging information. */
		660
		661	void *
		662	debug_init (void)
		663	{
		664	struct debug_handle *ret;
		665
		666	ret = (struct debug_handle ) xmalloc (sizeof ret);
		667	memset (ret, 0, sizeof *ret);
		668	return (void *) ret;
		669	}
		670
		671	/* Set the source filename. This implicitly starts a new compilation
		672	unit. */
		673
		674	bfd_boolean
		675	debug_set_filename (void handle, const char name)
		676	{
		677	struct debug_handle info = (struct debug_handle ) handle;
		678	struct debug_file *nfile;
		679	struct debug_unit *nunit;
		680
		681	if (name == NULL)
		682	name = "";
		683
		684	nfile = (struct debug_file ) xmalloc (sizeof nfile);
		685	memset (nfile, 0, sizeof *nfile);
		686
		687	nfile->filename = name;
		688
		689	nunit = (struct debug_unit ) xmalloc (sizeof nunit);
		690	memset (nunit, 0, sizeof *nunit);
		691
		692	nunit->files = nfile;
		693	info->current_file = nfile;
		694
		695	if (info->current_unit != NULL)
		696	info->current_unit->next = nunit;
		697	else
		698	{
		699	assert (info->units == NULL);
		700	info->units = nunit;
		701	}
		702
		703	info->current_unit = nunit;
		704
		705	info->current_function = NULL;
		706	info->current_block = NULL;
		707	info->current_lineno = NULL;
		708
		709	return TRUE;
		710	}
		711
		712	/* Change source files to the given file name. This is used for
		713	include files in a single compilation unit. */
		714
		715	bfd_boolean
		716	debug_start_source (void handle, const char name)
		717	{
		718	struct debug_handle info = (struct debug_handle ) handle;
		719	struct debug_file f, *pf;
		720
		721	if (name == NULL)
		722	name = "";
		723
		724	if (info->current_unit == NULL)
		725	{
		726	debug_error (_("debug_start_source: no debug_set_filename call"));
		727	return FALSE;
		728	}
		729
		730	for (f = info->current_unit->files; f != NULL; f = f->next)
		731	{
		732	if (filename_cmp (f->filename, name) == 0)
		733	{
		734	info->current_file = f;
		735	return TRUE;
		736	}
		737	}
		738
		739	f = (struct debug_file ) xmalloc (sizeof f);
		740	memset (f, 0, sizeof *f);
		741
		742	f->filename = name;
		743
		744	for (pf = &info->current_file->next;
		745	*pf != NULL;
		746	pf = &(*pf)->next)
		747	;
		748	*pf = f;
		749
		750	info->current_file = f;
		751
		752	return TRUE;
		753	}
		754
		755	/* Record a function definition. This implicitly starts a function
		756	block. The debug_type argument is the type of the return value.
		757	The boolean indicates whether the function is globally visible.
		758	The bfd_vma is the address of the start of the function. Currently
		759	the parameter types are specified by calls to
		760	debug_record_parameter. FIXME: There is no way to specify nested
		761	functions. */
		762
		763	bfd_boolean
		764	debug_record_function (void handle, const char name,
		765	debug_type return_type, bfd_boolean global,
		766	bfd_vma addr)
		767	{
		768	struct debug_handle info = (struct debug_handle ) handle;
		769	struct debug_function *f;
		770	struct debug_block *b;
		771	struct debug_name *n;
		772
		773	if (name == NULL)
		774	name = "";
		775	if (return_type == NULL)
		776	return FALSE;
		777
		778	if (info->current_unit == NULL)
		779	{
		780	debug_error (_("debug_record_function: no debug_set_filename call"));
		781	return FALSE;
		782	}
		783
		784	f = (struct debug_function ) xmalloc (sizeof f);
		785	memset (f, 0, sizeof *f);
		786
		787	f->return_type = return_type;
		788
		789	b = (struct debug_block ) xmalloc (sizeof b);
		790	memset (b, 0, sizeof *b);
		791
		792	b->start = addr;
		793	b->end = (bfd_vma) -1;
		794
		795	f->blocks = b;
		796
		797	info->current_function = f;
		798	info->current_block = b;
		799
		800	/* FIXME: If we could handle nested functions, this would be the
		801	place: we would want to use a different namespace. */
		802	n = debug_add_to_namespace (info,
		803	&info->current_file->globals,
		804	name,
		805	DEBUG_OBJECT_FUNCTION,
		806	(global
		807	? DEBUG_LINKAGE_GLOBAL
		808	: DEBUG_LINKAGE_STATIC));
		809	if (n == NULL)
		810	return FALSE;
		811
		812	n->u.function = f;
		813
		814	return TRUE;
		815	}
		816
		817	/* Record a parameter for the current function. */
		818
		819	bfd_boolean
		820	debug_record_parameter (void handle, const char name, debug_type type,
		821	enum debug_parm_kind kind, bfd_vma val)
		822	{
		823	struct debug_handle info = (struct debug_handle ) handle;
		824	struct debug_parameter p, *pp;
		825
		826	if (name == NULL \|\| type == NULL)
		827	return FALSE;
		828
		829	if (info->current_unit == NULL
		830	\|\| info->current_function == NULL)
		831	{
		832	debug_error (_("debug_record_parameter: no current function"));
		833	return FALSE;
		834	}
		835
		836	p = (struct debug_parameter ) xmalloc (sizeof p);
		837	memset (p, 0, sizeof *p);
		838
		839	p->name = name;
		840	p->type = type;
		841	p->kind = kind;
		842	p->val = val;
		843
		844	for (pp = &info->current_function->parameters;
		845	*pp != NULL;
		846	pp = &(*pp)->next)
		847	;
		848	*pp = p;
		849
		850	return TRUE;
		851	}
		852
		853	/* End a function. FIXME: This should handle function nesting. */
		854
		855	bfd_boolean
		856	debug_end_function (void *handle, bfd_vma addr)
		857	{
		858	struct debug_handle info = (struct debug_handle ) handle;
		859
		860	if (info->current_unit == NULL
		861	\|\| info->current_block == NULL
		862	\|\| info->current_function == NULL)
		863	{
		864	debug_error (_("debug_end_function: no current function"));
		865	return FALSE;
		866	}
		867
		868	if (info->current_block->parent != NULL)
		869	{
		870	debug_error (_("debug_end_function: some blocks were not closed"));
		871	return FALSE;
		872	}
		873
		874	info->current_block->end = addr;
		875
		876	info->current_function = NULL;
		877	info->current_block = NULL;
		878
		879	return TRUE;
		880	}
		881
		882	/* Start a block in a function. All local information will be
		883	recorded in this block, until the matching call to debug_end_block.
		884	debug_start_block and debug_end_block may be nested. The bfd_vma
		885	argument is the address at which this block starts. */
		886
		887	bfd_boolean
		888	debug_start_block (void *handle, bfd_vma addr)
		889	{
		890	struct debug_handle info = (struct debug_handle ) handle;
		891	struct debug_block b, *pb;
		892
		893	/* We must always have a current block: debug_record_function sets
		894	one up. */
		895	if (info->current_unit == NULL
		896	\|\| info->current_block == NULL)
		897	{
		898	debug_error (_("debug_start_block: no current block"));
		899	return FALSE;
		900	}
		901
		902	b = (struct debug_block ) xmalloc (sizeof b);
		903	memset (b, 0, sizeof *b);
		904
		905	b->parent = info->current_block;
		906	b->start = addr;
		907	b->end = (bfd_vma) -1;
		908
		909	/* This new block is a child of the current block. */
		910	for (pb = &info->current_block->children;
		911	*pb != NULL;
		912	pb = &(*pb)->next)
		913	;
		914	*pb = b;
		915
		916	info->current_block = b;
		917
		918	return TRUE;
		919	}
		920
		921	/* Finish a block in a function. This matches the call to
		922	debug_start_block. The argument is the address at which this block
		923	ends. */
		924
		925	bfd_boolean
		926	debug_end_block (void *handle, bfd_vma addr)
		927	{
		928	struct debug_handle info = (struct debug_handle ) handle;
		929	struct debug_block *parent;
		930
		931	if (info->current_unit == NULL
		932	\|\| info->current_block == NULL)
		933	{
		934	debug_error (_("debug_end_block: no current block"));
		935	return FALSE;
		936	}
		937
		938	parent = info->current_block->parent;
		939	if (parent == NULL)
		940	{
		941	debug_error (_("debug_end_block: attempt to close top level block"));
		942	return FALSE;
		943	}
		944
		945	info->current_block->end = addr;
		946
		947	info->current_block = parent;
		948
		949	return TRUE;
		950	}
		951
		952	/* Associate a line number in the current source file and function
		953	with a given address. */
		954
		955	bfd_boolean
		956	debug_record_line (void *handle, unsigned long lineno, bfd_vma addr)
		957	{
		958	struct debug_handle info = (struct debug_handle ) handle;
		959	struct debug_lineno *l;
		960	unsigned int i;
		961
		962	if (info->current_unit == NULL)
		963	{
		964	debug_error (_("debug_record_line: no current unit"));
		965	return FALSE;
		966	}
		967
		968	l = info->current_lineno;
		969	if (l != NULL && l->file == info->current_file)
		970	{
		971	for (i = 0; i < DEBUG_LINENO_COUNT; i++)
		972	{
		973	if (l->linenos[i] == (unsigned long) -1)
		974	{
		975	l->linenos[i] = lineno;
		976	l->addrs[i] = addr;
		977	return TRUE;
		978	}
		979	}
		980	}
		981
		982	/* If we get here, then either 1) there is no current_lineno
		983	structure, which means this is the first line number in this
		984	compilation unit, 2) the current_lineno structure is for a
		985	different file, or 3) the current_lineno structure is full.
		986	Regardless, we want to allocate a new debug_lineno structure, put
		987	it in the right place, and make it the new current_lineno
		988	structure. */
		989
		990	l = (struct debug_lineno ) xmalloc (sizeof l);
		991	memset (l, 0, sizeof *l);
		992
		993	l->file = info->current_file;
		994	l->linenos[0] = lineno;
		995	l->addrs[0] = addr;
		996	for (i = 1; i < DEBUG_LINENO_COUNT; i++)
		997	l->linenos[i] = (unsigned long) -1;
		998
		999	if (info->current_lineno != NULL)
		1000	info->current_lineno->next = l;
		1001	else
		1002	info->current_unit->linenos = l;
		1003
		1004	info->current_lineno = l;
		1005
		1006	return TRUE;
		1007	}
		1008
		1009	/* Start a named common block. This is a block of variables that may
		1010	move in memory. */
		1011
		1012	bfd_boolean
		1013	debug_start_common_block (void *handle ATTRIBUTE_UNUSED,
		1014	const char *name ATTRIBUTE_UNUSED)
		1015	{
		1016	/* FIXME */
		1017	debug_error (_("debug_start_common_block: not implemented"));
		1018	return FALSE;
		1019	}
		1020
		1021	/* End a named common block. */
		1022
		1023	bfd_boolean
		1024	debug_end_common_block (void *handle ATTRIBUTE_UNUSED,
		1025	const char *name ATTRIBUTE_UNUSED)
		1026	{
		1027	/* FIXME */
		1028	debug_error (_("debug_end_common_block: not implemented"));
		1029	return FALSE;
		1030	}
		1031
		1032	/* Record a named integer constant. */
		1033
		1034	bfd_boolean
		1035	debug_record_int_const (void handle, const char name, bfd_vma val)
		1036	{
		1037	struct debug_handle info = (struct debug_handle ) handle;
		1038	struct debug_name *n;
		1039
		1040	if (name == NULL)
		1041	return FALSE;
		1042
		1043	n = debug_add_to_current_namespace (info, name, DEBUG_OBJECT_INT_CONSTANT,
		1044	DEBUG_LINKAGE_NONE);
		1045	if (n == NULL)
		1046	return FALSE;
		1047
		1048	n->u.int_constant = val;
		1049
		1050	return TRUE;
		1051	}
		1052
		1053	/* Record a named floating point constant. */
		1054
		1055	bfd_boolean
		1056	debug_record_float_const (void handle, const char name, double val)
		1057	{
		1058	struct debug_handle info = (struct debug_handle ) handle;
		1059	struct debug_name *n;
		1060
		1061	if (name == NULL)
		1062	return FALSE;
		1063
		1064	n = debug_add_to_current_namespace (info, name, DEBUG_OBJECT_FLOAT_CONSTANT,
		1065	DEBUG_LINKAGE_NONE);
		1066	if (n == NULL)
		1067	return FALSE;
		1068
		1069	n->u.float_constant = val;
		1070
		1071	return TRUE;
		1072	}
		1073
		1074	/* Record a typed constant with an integral value. */
		1075
		1076	bfd_boolean
		1077	debug_record_typed_const (void handle, const char name, debug_type type,
		1078	bfd_vma val)
		1079	{
		1080	struct debug_handle info = (struct debug_handle ) handle;
		1081	struct debug_name *n;
		1082	struct debug_typed_constant *tc;
		1083
		1084	if (name == NULL \|\| type == NULL)
		1085	return FALSE;
		1086
		1087	n = debug_add_to_current_namespace (info, name, DEBUG_OBJECT_TYPED_CONSTANT,
		1088	DEBUG_LINKAGE_NONE);
		1089	if (n == NULL)
		1090	return FALSE;
		1091
		1092	tc = (struct debug_typed_constant ) xmalloc (sizeof tc);
		1093	memset (tc, 0, sizeof *tc);
		1094
		1095	tc->type = type;
		1096	tc->val = val;
		1097
		1098	n->u.typed_constant = tc;
		1099
		1100	return TRUE;
		1101	}
		1102
		1103	/* Record a label. */
		1104
		1105	bfd_boolean
		1106	debug_record_label (void *handle ATTRIBUTE_UNUSED,
		1107	const char *name ATTRIBUTE_UNUSED,
		1108	debug_type type ATTRIBUTE_UNUSED,
		1109	bfd_vma addr ATTRIBUTE_UNUSED)
		1110	{
		1111	/* FIXME. */
		1112	debug_error (_("debug_record_label: not implemented"));
		1113	return FALSE;
		1114	}
		1115
		1116	/* Record a variable. */
		1117
		1118	bfd_boolean
		1119	debug_record_variable (void handle, const char name, debug_type type,
		1120	enum debug_var_kind kind, bfd_vma val)
		1121	{
		1122	struct debug_handle info = (struct debug_handle ) handle;
		1123	struct debug_namespace **nsp;
		1124	enum debug_object_linkage linkage;
		1125	struct debug_name *n;
		1126	struct debug_variable *v;
		1127
		1128	if (name == NULL \|\| type == NULL)
		1129	return FALSE;
		1130
		1131	if (info->current_unit == NULL
		1132	\|\| info->current_file == NULL)
		1133	{
		1134	debug_error (_("debug_record_variable: no current file"));
		1135	return FALSE;
		1136	}
		1137
		1138	if (kind == DEBUG_GLOBAL \|\| kind == DEBUG_STATIC)
		1139	{
		1140	nsp = &info->current_file->globals;
		1141	if (kind == DEBUG_GLOBAL)
		1142	linkage = DEBUG_LINKAGE_GLOBAL;
		1143	else
		1144	linkage = DEBUG_LINKAGE_STATIC;
		1145	}
		1146	else
		1147	{
		1148	if (info->current_block == NULL)
		1149	nsp = &info->current_file->globals;
		1150	else
		1151	nsp = &info->current_block->locals;
		1152	linkage = DEBUG_LINKAGE_AUTOMATIC;
		1153	}
		1154
		1155	n = debug_add_to_namespace (info, nsp, name, DEBUG_OBJECT_VARIABLE, linkage);
		1156	if (n == NULL)
		1157	return FALSE;
		1158
		1159	v = (struct debug_variable ) xmalloc (sizeof v);
		1160	memset (v, 0, sizeof *v);
		1161
		1162	v->kind = kind;
		1163	v->type = type;
		1164	v->val = val;
		1165
		1166	n->u.variable = v;
		1167
		1168	return TRUE;
		1169	}
		1170
		1171	/* Make a type with a given kind and size. */
		1172
		1173	static struct debug_type_s *
		1174	debug_make_type (struct debug_handle *info ATTRIBUTE_UNUSED,
		1175	enum debug_type_kind kind, unsigned int size)
		1176	{
		1177	struct debug_type_s *t;
		1178
		1179	t = (struct debug_type_s ) xmalloc (sizeof t);
		1180	memset (t, 0, sizeof *t);
		1181
		1182	t->kind = kind;
		1183	t->size = size;
		1184
		1185	return t;
		1186	}
		1187
		1188	/* Make an indirect type which may be used as a placeholder for a type
		1189	which is referenced before it is defined. */
		1190
		1191	debug_type
		1192	debug_make_indirect_type (void handle, debug_type slot, const char *tag)
		1193	{
		1194	struct debug_handle info = (struct debug_handle ) handle;
		1195	struct debug_type_s *t;
		1196	struct debug_indirect_type *i;
		1197
		1198	t = debug_make_type (info, DEBUG_KIND_INDIRECT, 0);
		1199	if (t == NULL)
		1200	return DEBUG_TYPE_NULL;
		1201
		1202	i = (struct debug_indirect_type ) xmalloc (sizeof i);
		1203	memset (i, 0, sizeof *i);
		1204
		1205	i->slot = slot;
		1206	i->tag = tag;
		1207
		1208	t->u.kindirect = i;
		1209
		1210	return t;
		1211	}
		1212
		1213	/* Make a void type. There is only one of these. */
		1214
		1215	debug_type
		1216	debug_make_void_type (void *handle)
		1217	{
		1218	struct debug_handle info = (struct debug_handle ) handle;
		1219
		1220	return debug_make_type (info, DEBUG_KIND_VOID, 0);
		1221	}
		1222
		1223	/* Make an integer type of a given size. The boolean argument is true
		1224	if the integer is unsigned. */
		1225
		1226	debug_type
		1227	debug_make_int_type (void *handle, unsigned int size, bfd_boolean unsignedp)
		1228	{
		1229	struct debug_handle info = (struct debug_handle ) handle;
		1230	struct debug_type_s *t;
		1231
		1232	t = debug_make_type (info, DEBUG_KIND_INT, size);
		1233	if (t == NULL)
		1234	return DEBUG_TYPE_NULL;
		1235
		1236	t->u.kint = unsignedp;
		1237
		1238	return t;
		1239	}
		1240
		1241	/* Make a floating point type of a given size. FIXME: On some
		1242	platforms, like an Alpha, you probably need to be able to specify
		1243	the format. */
		1244
		1245	debug_type
		1246	debug_make_float_type (void *handle, unsigned int size)
		1247	{
		1248	struct debug_handle info = (struct debug_handle ) handle;
		1249
		1250	return debug_make_type (info, DEBUG_KIND_FLOAT, size);
		1251	}
		1252
		1253	/* Make a boolean type of a given size. */
		1254
		1255	debug_type
		1256	debug_make_bool_type (void *handle, unsigned int size)
		1257	{
		1258	struct debug_handle info = (struct debug_handle ) handle;
		1259
		1260	return debug_make_type (info, DEBUG_KIND_BOOL, size);
		1261	}
		1262
		1263	/* Make a complex type of a given size. */
		1264
		1265	debug_type
		1266	debug_make_complex_type (void *handle, unsigned int size)
		1267	{
		1268	struct debug_handle info = (struct debug_handle ) handle;
		1269
		1270	return debug_make_type (info, DEBUG_KIND_COMPLEX, size);
		1271	}
		1272
		1273	/* Make a structure type. The second argument is true for a struct,
		1274	false for a union. The third argument is the size of the struct.
		1275	The fourth argument is a NULL terminated array of fields. */
		1276
		1277	debug_type
		1278	debug_make_struct_type (void *handle, bfd_boolean structp, bfd_vma size,
		1279	debug_field *fields)
		1280	{
		1281	struct debug_handle info = (struct debug_handle ) handle;
		1282	struct debug_type_s *t;
		1283	struct debug_class_type *c;
		1284
		1285	t = debug_make_type (info,
		1286	structp ? DEBUG_KIND_STRUCT : DEBUG_KIND_UNION,
		1287	size);
		1288	if (t == NULL)
		1289	return DEBUG_TYPE_NULL;
		1290
		1291	c = (struct debug_class_type ) xmalloc (sizeof c);
		1292	memset (c, 0, sizeof *c);
		1293
		1294	c->fields = fields;
		1295
		1296	t->u.kclass = c;
		1297
		1298	return t;
		1299	}
		1300
		1301	/* Make an object type. The first three arguments after the handle
		1302	are the same as for debug_make_struct_type. The next arguments are
		1303	a NULL terminated array of base classes, a NULL terminated array of
		1304	methods, the type of the object holding the virtual function table
		1305	if it is not this object, and a boolean which is true if this
		1306	object has its own virtual function table. */
		1307
		1308	debug_type
		1309	debug_make_object_type (void *handle, bfd_boolean structp, bfd_vma size,
		1310	debug_field fields, debug_baseclass baseclasses,
		1311	debug_method *methods, debug_type vptrbase,
		1312	bfd_boolean ownvptr)
		1313	{
		1314	struct debug_handle info = (struct debug_handle ) handle;
		1315	struct debug_type_s *t;
		1316	struct debug_class_type *c;
		1317
		1318	t = debug_make_type (info,
		1319	structp ? DEBUG_KIND_CLASS : DEBUG_KIND_UNION_CLASS,
		1320	size);
		1321	if (t == NULL)
		1322	return DEBUG_TYPE_NULL;
		1323
		1324	c = (struct debug_class_type ) xmalloc (sizeof c);
		1325	memset (c, 0, sizeof *c);
		1326
		1327	c->fields = fields;
		1328	c->baseclasses = baseclasses;
		1329	c->methods = methods;
		1330	if (ownvptr)
		1331	c->vptrbase = t;
		1332	else
		1333	c->vptrbase = vptrbase;
		1334
		1335	t->u.kclass = c;
		1336
		1337	return t;
		1338	}
		1339
		1340	/* Make an enumeration type. The arguments are a null terminated
		1341	array of strings, and an array of corresponding values. */
		1342
		1343	debug_type
		1344	debug_make_enum_type (void handle, const char *names,
		1345	bfd_signed_vma *values)
		1346	{
		1347	struct debug_handle info = (struct debug_handle ) handle;
		1348	struct debug_type_s *t;
		1349	struct debug_enum_type *e;
		1350
		1351	t = debug_make_type (info, DEBUG_KIND_ENUM, 0);
		1352	if (t == NULL)
		1353	return DEBUG_TYPE_NULL;
		1354
		1355	e = (struct debug_enum_type ) xmalloc (sizeof e);
		1356	memset (e, 0, sizeof *e);
		1357
		1358	e->names = names;
		1359	e->values = values;
		1360
		1361	t->u.kenum = e;
		1362
		1363	return t;
		1364	}
		1365
		1366	/* Make a pointer to a given type. */
		1367
		1368	debug_type
		1369	debug_make_pointer_type (void *handle, debug_type type)
		1370	{
		1371	struct debug_handle info = (struct debug_handle ) handle;
		1372	struct debug_type_s *t;
		1373
		1374	if (type == NULL)
		1375	return DEBUG_TYPE_NULL;
		1376
		1377	if (type->pointer != DEBUG_TYPE_NULL)
		1378	return type->pointer;
		1379
		1380	t = debug_make_type (info, DEBUG_KIND_POINTER, 0);
		1381	if (t == NULL)
		1382	return DEBUG_TYPE_NULL;
		1383
		1384	t->u.kpointer = type;
		1385
		1386	type->pointer = t;
		1387
		1388	return t;
		1389	}
		1390
		1391	/* Make a function returning a given type. FIXME: We should be able
		1392	to record the parameter types. */
		1393
		1394	debug_type
		1395	debug_make_function_type (void *handle, debug_type type,
		1396	debug_type *arg_types, bfd_boolean varargs)
		1397	{
		1398	struct debug_handle info = (struct debug_handle ) handle;
		1399	struct debug_type_s *t;
		1400	struct debug_function_type *f;
		1401
		1402	if (type == NULL)
		1403	return DEBUG_TYPE_NULL;
		1404
		1405	t = debug_make_type (info, DEBUG_KIND_FUNCTION, 0);
		1406	if (t == NULL)
		1407	return DEBUG_TYPE_NULL;
		1408
		1409	f = (struct debug_function_type ) xmalloc (sizeof f);
		1410	memset (f, 0, sizeof *f);
		1411
		1412	f->return_type = type;
		1413	f->arg_types = arg_types;
		1414	f->varargs = varargs;
		1415
		1416	t->u.kfunction = f;
		1417
		1418	return t;
		1419	}
		1420
		1421	/* Make a reference to a given type. */
		1422
		1423	debug_type
		1424	debug_make_reference_type (void *handle, debug_type type)
		1425	{
		1426	struct debug_handle info = (struct debug_handle ) handle;
		1427	struct debug_type_s *t;
		1428
		1429	if (type == NULL)
		1430	return DEBUG_TYPE_NULL;
		1431
		1432	t = debug_make_type (info, DEBUG_KIND_REFERENCE, 0);
		1433	if (t == NULL)
		1434	return DEBUG_TYPE_NULL;
		1435
		1436	t->u.kreference = type;
		1437
		1438	return t;
		1439	}
		1440
		1441	/* Make a range of a given type from a lower to an upper bound. */
		1442
		1443	debug_type
		1444	debug_make_range_type (void *handle, debug_type type, bfd_signed_vma lower,
		1445	bfd_signed_vma upper)
		1446	{
		1447	struct debug_handle info = (struct debug_handle ) handle;
		1448	struct debug_type_s *t;
		1449	struct debug_range_type *r;
		1450
		1451	if (type == NULL)
		1452	return DEBUG_TYPE_NULL;
		1453
		1454	t = debug_make_type (info, DEBUG_KIND_RANGE, 0);
		1455	if (t == NULL)
		1456	return DEBUG_TYPE_NULL;
		1457
		1458	r = (struct debug_range_type ) xmalloc (sizeof r);
		1459	memset (r, 0, sizeof *r);
		1460
		1461	r->type = type;
		1462	r->lower = lower;
		1463	r->upper = upper;
		1464
		1465	t->u.krange = r;
		1466
		1467	return t;
		1468	}
		1469
		1470	/* Make an array type. The second argument is the type of an element
		1471	of the array. The third argument is the type of a range of the
		1472	array. The fourth and fifth argument are the lower and upper
		1473	bounds, respectively. The sixth argument is true if this array is
		1474	actually a string, as in C. */
		1475
		1476	debug_type
		1477	debug_make_array_type (void *handle, debug_type element_type,
		1478	debug_type range_type, bfd_signed_vma lower,
		1479	bfd_signed_vma upper, bfd_boolean stringp)
		1480	{
		1481	struct debug_handle info = (struct debug_handle ) handle;
		1482	struct debug_type_s *t;
		1483	struct debug_array_type *a;
		1484
		1485	if (element_type == NULL \|\| range_type == NULL)
		1486	return DEBUG_TYPE_NULL;
		1487
		1488	t = debug_make_type (info, DEBUG_KIND_ARRAY, 0);
		1489	if (t == NULL)
		1490	return DEBUG_TYPE_NULL;
		1491
		1492	a = (struct debug_array_type ) xmalloc (sizeof a);
		1493	memset (a, 0, sizeof *a);
		1494
		1495	a->element_type = element_type;
		1496	a->range_type = range_type;
		1497	a->lower = lower;
		1498	a->upper = upper;
		1499	a->stringp = stringp;
		1500
		1501	t->u.karray = a;
		1502
		1503	return t;
		1504	}
		1505
		1506	/* Make a set of a given type. For example, a Pascal set type. The
		1507	boolean argument is true if this set is actually a bitstring, as in
		1508	CHILL. */
		1509
		1510	debug_type
		1511	debug_make_set_type (void *handle, debug_type type, bfd_boolean bitstringp)
		1512	{
		1513	struct debug_handle info = (struct debug_handle ) handle;
		1514	struct debug_type_s *t;
		1515	struct debug_set_type *s;
		1516
		1517	if (type == NULL)
		1518	return DEBUG_TYPE_NULL;
		1519
		1520	t = debug_make_type (info, DEBUG_KIND_SET, 0);
		1521	if (t == NULL)
		1522	return DEBUG_TYPE_NULL;
		1523
		1524	s = (struct debug_set_type ) xmalloc (sizeof s);
		1525	memset (s, 0, sizeof *s);
		1526
		1527	s->type = type;
		1528	s->bitstringp = bitstringp;
		1529
		1530	t->u.kset = s;
		1531
		1532	return t;
		1533	}
		1534
		1535	/* Make a type for a pointer which is relative to an object. The
		1536	second argument is the type of the object to which the pointer is
		1537	relative. The third argument is the type that the pointer points
		1538	to. */
		1539
		1540	debug_type
		1541	debug_make_offset_type (void *handle, debug_type base_type,
		1542	debug_type target_type)
		1543	{
		1544	struct debug_handle info = (struct debug_handle ) handle;
		1545	struct debug_type_s *t;
		1546	struct debug_offset_type *o;
		1547
		1548	if (base_type == NULL \|\| target_type == NULL)
		1549	return DEBUG_TYPE_NULL;
		1550
		1551	t = debug_make_type (info, DEBUG_KIND_OFFSET, 0);
		1552	if (t == NULL)
		1553	return DEBUG_TYPE_NULL;
		1554
		1555	o = (struct debug_offset_type ) xmalloc (sizeof o);
		1556	memset (o, 0, sizeof *o);
		1557
		1558	o->base_type = base_type;
		1559	o->target_type = target_type;
		1560
		1561	t->u.koffset = o;
		1562
		1563	return t;
		1564	}
		1565
		1566	/* Make a type for a method function. The second argument is the
		1567	return type, the third argument is the domain, and the fourth
		1568	argument is a NULL terminated array of argument types. */
		1569
		1570	debug_type
		1571	debug_make_method_type (void *handle, debug_type return_type,
		1572	debug_type domain_type, debug_type *arg_types,
		1573	bfd_boolean varargs)
		1574	{
		1575	struct debug_handle info = (struct debug_handle ) handle;
		1576	struct debug_type_s *t;
		1577	struct debug_method_type *m;
		1578
		1579	if (return_type == NULL)
		1580	return DEBUG_TYPE_NULL;
		1581
		1582	t = debug_make_type (info, DEBUG_KIND_METHOD, 0);
		1583	if (t == NULL)
		1584	return DEBUG_TYPE_NULL;
		1585
		1586	m = (struct debug_method_type ) xmalloc (sizeof m);
		1587	memset (m, 0, sizeof *m);
		1588
		1589	m->return_type = return_type;
		1590	m->domain_type = domain_type;
		1591	m->arg_types = arg_types;
		1592	m->varargs = varargs;
		1593
		1594	t->u.kmethod = m;
		1595
		1596	return t;
		1597	}
		1598
		1599	/* Make a const qualified version of a given type. */
		1600
		1601	debug_type
		1602	debug_make_const_type (void *handle, debug_type type)
		1603	{
		1604	struct debug_handle info = (struct debug_handle ) handle;
		1605	struct debug_type_s *t;
		1606
		1607	if (type == NULL)
		1608	return DEBUG_TYPE_NULL;
		1609
		1610	t = debug_make_type (info, DEBUG_KIND_CONST, 0);
		1611	if (t == NULL)
		1612	return DEBUG_TYPE_NULL;
		1613
		1614	t->u.kconst = type;
		1615
		1616	return t;
		1617	}
		1618
		1619	/* Make a volatile qualified version of a given type. */
		1620
		1621	debug_type
		1622	debug_make_volatile_type (void *handle, debug_type type)
		1623	{
		1624	struct debug_handle info = (struct debug_handle ) handle;
		1625	struct debug_type_s *t;
		1626
		1627	if (type == NULL)
		1628	return DEBUG_TYPE_NULL;
		1629
		1630	t = debug_make_type (info, DEBUG_KIND_VOLATILE, 0);
		1631	if (t == NULL)
		1632	return DEBUG_TYPE_NULL;
		1633
		1634	t->u.kvolatile = type;
		1635
		1636	return t;
		1637	}
		1638
		1639	/* Make an undefined tagged type. For example, a struct which has
		1640	been mentioned, but not defined. */
		1641
		1642	debug_type
		1643	debug_make_undefined_tagged_type (void handle, const char name,
		1644	enum debug_type_kind kind)
		1645	{
		1646	struct debug_handle info = (struct debug_handle ) handle;
		1647	struct debug_type_s *t;
		1648
		1649	if (name == NULL)
		1650	return DEBUG_TYPE_NULL;
		1651
		1652	switch (kind)
		1653	{
		1654	case DEBUG_KIND_STRUCT:
		1655	case DEBUG_KIND_UNION:
		1656	case DEBUG_KIND_CLASS:
		1657	case DEBUG_KIND_UNION_CLASS:
		1658	case DEBUG_KIND_ENUM:
		1659	break;
		1660
		1661	default:
		1662	debug_error (_("debug_make_undefined_type: unsupported kind"));
		1663	return DEBUG_TYPE_NULL;
		1664	}
		1665
		1666	t = debug_make_type (info, kind, 0);
		1667	if (t == NULL)
		1668	return DEBUG_TYPE_NULL;
		1669
		1670	return debug_tag_type (handle, name, t);
		1671	}
		1672
		1673	/* Make a base class for an object. The second argument is the base
		1674	class type. The third argument is the bit position of this base
		1675	class in the object (always 0 unless doing multiple inheritance).
		1676	The fourth argument is whether this is a virtual class. The fifth
		1677	argument is the visibility of the base class. */
		1678
		1679	debug_baseclass
		1680	debug_make_baseclass (void *handle ATTRIBUTE_UNUSED, debug_type type,
		1681	bfd_vma bitpos, bfd_boolean is_virtual,
		1682	enum debug_visibility visibility)
		1683	{
		1684	struct debug_baseclass_s *b;
		1685
		1686	b = (struct debug_baseclass_s ) xmalloc (sizeof b);
		1687	memset (b, 0, sizeof *b);
		1688
		1689	b->type = type;
		1690	b->bitpos = bitpos;
		1691	b->is_virtual = is_virtual;
		1692	b->visibility = visibility;
		1693
		1694	return b;
		1695	}
		1696
		1697	/* Make a field for a struct. The second argument is the name. The
		1698	third argument is the type of the field. The fourth argument is
		1699	the bit position of the field. The fifth argument is the size of
		1700	the field (it may be zero). The sixth argument is the visibility
		1701	of the field. */
		1702
		1703	debug_field
		1704	debug_make_field (void handle ATTRIBUTE_UNUSED, const char name,
		1705	debug_type type, bfd_vma bitpos, bfd_vma bitsize,
		1706	enum debug_visibility visibility)
		1707	{
		1708	struct debug_field_s *f;
		1709
		1710	f = (struct debug_field_s ) xmalloc (sizeof f);
		1711	memset (f, 0, sizeof *f);
		1712
		1713	f->name = name;
		1714	f->type = type;
		1715	f->static_member = FALSE;
		1716	f->u.f.bitpos = bitpos;
		1717	f->u.f.bitsize = bitsize;
		1718	f->visibility = visibility;
		1719
		1720	return f;
		1721	}
		1722
		1723	/* Make a static member of an object. The second argument is the
		1724	name. The third argument is the type of the member. The fourth
		1725	argument is the physical name of the member (i.e., the name as a
		1726	global variable). The fifth argument is the visibility of the
		1727	member. */
		1728
		1729	debug_field
		1730	debug_make_static_member (void handle ATTRIBUTE_UNUSED, const char name,
		1731	debug_type type, const char *physname,
		1732	enum debug_visibility visibility)
		1733	{
		1734	struct debug_field_s *f;
		1735
		1736	f = (struct debug_field_s ) xmalloc (sizeof f);
		1737	memset (f, 0, sizeof *f);
		1738
		1739	f->name = name;
		1740	f->type = type;
		1741	f->static_member = TRUE;
		1742	f->u.s.physname = physname;
		1743	f->visibility = visibility;
		1744
		1745	return f;
		1746	}
		1747
		1748	/* Make a method. The second argument is the name, and the third
		1749	argument is a NULL terminated array of method variants. */
		1750
		1751	debug_method
		1752	debug_make_method (void handle ATTRIBUTE_UNUSED, const char name,
		1753	debug_method_variant *variants)
		1754	{
		1755	struct debug_method_s *m;
		1756
		1757	m = (struct debug_method_s ) xmalloc (sizeof m);
		1758	memset (m, 0, sizeof *m);
		1759
		1760	m->name = name;
		1761	m->variants = variants;
		1762
		1763	return m;
		1764	}
		1765
		1766	/* Make a method argument. The second argument is the real name of
		1767	the function. The third argument is the type of the function. The
		1768	fourth argument is the visibility. The fifth argument is whether
		1769	this is a const function. The sixth argument is whether this is a
		1770	volatile function. The seventh argument is the offset in the
		1771	virtual function table, if any. The eighth argument is the virtual
		1772	function context. FIXME: Are the const and volatile arguments
		1773	necessary? Could we just use debug_make_const_type? */
		1774
		1775	debug_method_variant
		1776	debug_make_method_variant (void *handle ATTRIBUTE_UNUSED,
		1777	const char *physname, debug_type type,
		1778	enum debug_visibility visibility,
		1779	bfd_boolean constp, bfd_boolean volatilep,
		1780	bfd_vma voffset, debug_type context)
		1781	{
		1782	struct debug_method_variant_s *m;
		1783
		1784	m = (struct debug_method_variant_s ) xmalloc (sizeof m);
		1785	memset (m, 0, sizeof *m);
		1786
		1787	m->physname = physname;
		1788	m->type = type;
		1789	m->visibility = visibility;
		1790	m->constp = constp;
		1791	m->volatilep = volatilep;
		1792	m->voffset = voffset;
		1793	m->context = context;
		1794
		1795	return m;
		1796	}
		1797
		1798	/* Make a static method argument. The arguments are the same as for
		1799	debug_make_method_variant, except that the last two are omitted
		1800	since a static method can not also be virtual. */
		1801
		1802	debug_method_variant
		1803	debug_make_static_method_variant (void *handle ATTRIBUTE_UNUSED,
		1804	const char *physname, debug_type type,
		1805	enum debug_visibility visibility,
		1806	bfd_boolean constp, bfd_boolean volatilep)
		1807	{
		1808	struct debug_method_variant_s *m;
		1809
		1810	m = (struct debug_method_variant_s ) xmalloc (sizeof m);
		1811	memset (m, 0, sizeof *m);
		1812
		1813	m->physname = physname;
		1814	m->type = type;
		1815	m->visibility = visibility;
		1816	m->constp = constp;
		1817	m->volatilep = volatilep;
		1818	m->voffset = VOFFSET_STATIC_METHOD;
		1819
		1820	return m;
		1821	}
		1822
		1823	/* Name a type. */
		1824
		1825	debug_type
		1826	debug_name_type (void handle, const char name, debug_type type)
		1827	{
		1828	struct debug_handle info = (struct debug_handle ) handle;
		1829	struct debug_type_s *t;
		1830	struct debug_named_type *n;
		1831	struct debug_name *nm;
		1832
		1833	if (name == NULL \|\| type == NULL)
		1834	return DEBUG_TYPE_NULL;
		1835
		1836	if (info->current_unit == NULL
		1837	\|\| info->current_file == NULL)
		1838	{
		1839	debug_error (_("debug_name_type: no current file"));
		1840	return DEBUG_TYPE_NULL;
		1841	}
		1842
		1843	t = debug_make_type (info, DEBUG_KIND_NAMED, 0);
		1844	if (t == NULL)
		1845	return DEBUG_TYPE_NULL;
		1846
		1847	n = (struct debug_named_type ) xmalloc (sizeof n);
		1848	memset (n, 0, sizeof *n);
		1849
		1850	n->type = type;
		1851
		1852	t->u.knamed = n;
		1853
		1854	/* We always add the name to the global namespace. This is probably
		1855	wrong in some cases, but it seems to be right for stabs. FIXME. */
		1856
		1857	nm = debug_add_to_namespace (info, &info->current_file->globals, name,
		1858	DEBUG_OBJECT_TYPE, DEBUG_LINKAGE_NONE);
		1859	if (nm == NULL)
		1860	return DEBUG_TYPE_NULL;
		1861
		1862	nm->u.type = t;
		1863
		1864	n->name = nm;
		1865
		1866	return t;
		1867	}
		1868
		1869	/* Tag a type. */
		1870
		1871	debug_type
		1872	debug_tag_type (void handle, const char name, debug_type type)
		1873	{
		1874	struct debug_handle info = (struct debug_handle ) handle;
		1875	struct debug_type_s *t;
		1876	struct debug_named_type *n;
		1877	struct debug_name *nm;
		1878
		1879	if (name == NULL \|\| type == NULL)
		1880	return DEBUG_TYPE_NULL;
		1881
		1882	if (info->current_file == NULL)
		1883	{
		1884	debug_error (_("debug_tag_type: no current file"));
		1885	return DEBUG_TYPE_NULL;
		1886	}
		1887
		1888	if (type->kind == DEBUG_KIND_TAGGED)
		1889	{
		1890	if (strcmp (type->u.knamed->name->name, name) == 0)
		1891	return type;
		1892	debug_error (_("debug_tag_type: extra tag attempted"));
		1893	return DEBUG_TYPE_NULL;
		1894	}
		1895
		1896	t = debug_make_type (info, DEBUG_KIND_TAGGED, 0);
		1897	if (t == NULL)
		1898	return DEBUG_TYPE_NULL;
		1899
		1900	n = (struct debug_named_type ) xmalloc (sizeof n);
		1901	memset (n, 0, sizeof *n);
		1902
		1903	n->type = type;
		1904
		1905	t->u.knamed = n;
		1906
		1907	/* We keep a global namespace of tags for each compilation unit. I
		1908	don't know if that is the right thing to do. */
		1909
		1910	nm = debug_add_to_namespace (info, &info->current_file->globals, name,
		1911	DEBUG_OBJECT_TAG, DEBUG_LINKAGE_NONE);
		1912	if (nm == NULL)
		1913	return DEBUG_TYPE_NULL;
		1914
		1915	nm->u.tag = t;
		1916
		1917	n->name = nm;
		1918
		1919	return t;
		1920	}
		1921
		1922	/* Record the size of a given type. */
		1923
		1924	bfd_boolean
		1925	debug_record_type_size (void *handle ATTRIBUTE_UNUSED, debug_type type,
		1926	unsigned int size)
		1927	{
		1928	if (type->size != 0 && type->size != size)
		1929	fprintf (stderr, _("Warning: changing type size from %d to %d\n"),
		1930	type->size, size);
		1931
		1932	type->size = size;
		1933
		1934	return TRUE;
		1935	}
		1936
		1937	/* Find a named type. */
		1938
		1939	debug_type
		1940	debug_find_named_type (void handle, const char name)
		1941	{
		1942	struct debug_handle info = (struct debug_handle ) handle;
		1943	struct debug_block *b;
		1944	struct debug_file *f;
		1945
		1946	/* We only search the current compilation unit. I don't know if
		1947	this is right or not. */
		1948
		1949	if (info->current_unit == NULL)
		1950	{
		1951	debug_error (_("debug_find_named_type: no current compilation unit"));
		1952	return DEBUG_TYPE_NULL;
		1953	}
		1954
		1955	for (b = info->current_block; b != NULL; b = b->parent)
		1956	{
		1957	if (b->locals != NULL)
		1958	{
		1959	struct debug_name *n;
		1960
		1961	for (n = b->locals->list; n != NULL; n = n->next)
		1962	{
		1963	if (n->kind == DEBUG_OBJECT_TYPE
		1964	&& n->name[0] == name[0]
		1965	&& strcmp (n->name, name) == 0)
		1966	return n->u.type;
		1967	}
		1968	}
		1969	}
		1970
		1971	for (f = info->current_unit->files; f != NULL; f = f->next)
		1972	{
		1973	if (f->globals != NULL)
		1974	{
		1975	struct debug_name *n;
		1976
		1977	for (n = f->globals->list; n != NULL; n = n->next)
		1978	{
		1979	if (n->kind == DEBUG_OBJECT_TYPE
		1980	&& n->name[0] == name[0]
		1981	&& strcmp (n->name, name) == 0)
		1982	return n->u.type;
		1983	}
		1984	}
		1985	}
		1986
		1987	return DEBUG_TYPE_NULL;
		1988	}
		1989
		1990	/* Find a tagged type. */
		1991
		1992	debug_type
		1993	debug_find_tagged_type (void handle, const char name,
		1994	enum debug_type_kind kind)
		1995	{
		1996	struct debug_handle info = (struct debug_handle ) handle;
		1997	struct debug_unit *u;
		1998
		1999	/* We search the globals of all the compilation units. I don't know
		2000	if this is correct or not. It would be easy to change. */
		2001
		2002	for (u = info->units; u != NULL; u = u->next)
		2003	{
		2004	struct debug_file *f;
		2005
		2006	for (f = u->files; f != NULL; f = f->next)
		2007	{
		2008	struct debug_name *n;
		2009
		2010	if (f->globals != NULL)
		2011	{
		2012	for (n = f->globals->list; n != NULL; n = n->next)
		2013	{
		2014	if (n->kind == DEBUG_OBJECT_TAG
		2015	&& (kind == DEBUG_KIND_ILLEGAL
		2016	\|\| n->u.tag->kind == kind)
		2017	&& n->name[0] == name[0]
		2018	&& strcmp (n->name, name) == 0)
		2019	return n->u.tag;
		2020	}
		2021	}
		2022	}
		2023	}
		2024
		2025	return DEBUG_TYPE_NULL;
		2026	}
		2027
		2028	/* Get a base type. We build a linked list on the stack to avoid
		2029	crashing if the type is defined circularly. */
		2030
		2031	static struct debug_type_s *
		2032	debug_get_real_type (void *handle, debug_type type,
		2033	struct debug_type_real_list *list)
		2034	{
		2035	struct debug_type_real_list *l;
		2036	struct debug_type_real_list rl;
		2037
		2038	switch (type->kind)
		2039	{
		2040	default:
		2041	return type;
		2042
		2043	case DEBUG_KIND_INDIRECT:
		2044	case DEBUG_KIND_NAMED:
		2045	case DEBUG_KIND_TAGGED:
		2046	break;
		2047	}
		2048
		2049	for (l = list; l != NULL; l = l->next)
		2050	{
		2051	if (l->t == type \|\| l == l->next)
		2052	{
		2053	fprintf (stderr,
		2054	_("debug_get_real_type: circular debug information for %s\n"),
		2055	debug_get_type_name (handle, type));
		2056	return NULL;
		2057	}
		2058	}
		2059
		2060	rl.next = list;
		2061	rl.t = type;
		2062
		2063	switch (type->kind)
		2064	{
		2065	/* The default case is just here to avoid warnings. */
		2066	default:
		2067	case DEBUG_KIND_INDIRECT:
		2068	if (*type->u.kindirect->slot != NULL)
		2069	return debug_get_real_type (handle, *type->u.kindirect->slot, &rl);
		2070	return type;
		2071	case DEBUG_KIND_NAMED:
		2072	case DEBUG_KIND_TAGGED:
		2073	return debug_get_real_type (handle, type->u.knamed->type, &rl);
		2074	}
		2075	/NOTREACHED/
		2076	}
		2077
		2078	/* Get the kind of a type. */
		2079
		2080	enum debug_type_kind
		2081	debug_get_type_kind (void *handle, debug_type type)
		2082	{
		2083	if (type == NULL)
		2084	return DEBUG_KIND_ILLEGAL;
		2085	type = debug_get_real_type (handle, type, NULL);
		2086	if (type == NULL)
		2087	return DEBUG_KIND_ILLEGAL;
		2088	return type->kind;
		2089	}
		2090
		2091	/* Get the name of a type. */
		2092
		2093	const char *
		2094	debug_get_type_name (void *handle, debug_type type)
		2095	{
		2096	if (type->kind == DEBUG_KIND_INDIRECT)
		2097	{
		2098	if (*type->u.kindirect->slot != NULL)
		2099	return debug_get_type_name (handle, *type->u.kindirect->slot);
		2100	return type->u.kindirect->tag;
		2101	}
		2102	if (type->kind == DEBUG_KIND_NAMED
		2103	\|\| type->kind == DEBUG_KIND_TAGGED)
		2104	return type->u.knamed->name->name;
		2105	return NULL;
		2106	}
		2107
		2108	/* Get the size of a type. */
		2109
		2110	bfd_vma
		2111	debug_get_type_size (void *handle, debug_type type)
		2112	{
		2113	if (type == NULL)
		2114	return 0;
		2115
		2116	/* We don't call debug_get_real_type, because somebody might have
		2117	called debug_record_type_size on a named or indirect type. */
		2118
		2119	if (type->size != 0)
		2120	return type->size;
		2121
		2122	switch (type->kind)
		2123	{
		2124	default:
		2125	return 0;
		2126	case DEBUG_KIND_INDIRECT:
		2127	if (*type->u.kindirect->slot != NULL)
		2128	return debug_get_type_size (handle, *type->u.kindirect->slot);
		2129	return 0;
		2130	case DEBUG_KIND_NAMED:
		2131	case DEBUG_KIND_TAGGED:
		2132	return debug_get_type_size (handle, type->u.knamed->type);
		2133	}
		2134	/NOTREACHED/
		2135	}
		2136
		2137	/* Get the return type of a function or method type. */
		2138
		2139	debug_type
		2140	debug_get_return_type (void *handle, debug_type type)
		2141	{
		2142	if (type == NULL)
		2143	return DEBUG_TYPE_NULL;
		2144
		2145	type = debug_get_real_type (handle, type, NULL);
		2146	if (type == NULL)
		2147	return DEBUG_TYPE_NULL;
		2148
		2149	switch (type->kind)
		2150	{
		2151	default:
		2152	return DEBUG_TYPE_NULL;
		2153	case DEBUG_KIND_FUNCTION:
		2154	return type->u.kfunction->return_type;
		2155	case DEBUG_KIND_METHOD:
		2156	return type->u.kmethod->return_type;
		2157	}
		2158	/NOTREACHED/
		2159	}
		2160
		2161	/* Get the parameter types of a function or method type (except that
		2162	we don't currently store the parameter types of a function). */
		2163
		2164	const debug_type *
		2165	debug_get_parameter_types (void *handle, debug_type type,
		2166	bfd_boolean *pvarargs)
		2167	{
		2168	if (type == NULL)
		2169	return NULL;
		2170
		2171	type = debug_get_real_type (handle, type, NULL);
		2172	if (type == NULL)
		2173	return NULL;
		2174
		2175	switch (type->kind)
		2176	{
		2177	default:
		2178	return NULL;
		2179	case DEBUG_KIND_FUNCTION:
		2180	*pvarargs = type->u.kfunction->varargs;
		2181	return type->u.kfunction->arg_types;
		2182	case DEBUG_KIND_METHOD:
		2183	*pvarargs = type->u.kmethod->varargs;
		2184	return type->u.kmethod->arg_types;
		2185	}
		2186	/NOTREACHED/
		2187	}
		2188
		2189	/* Get the target type of a type. */
		2190
		2191	debug_type
		2192	debug_get_target_type (void *handle, debug_type type)
		2193	{
		2194	if (type == NULL)
		2195	return NULL;
		2196
		2197	type = debug_get_real_type (handle, type, NULL);
		2198	if (type == NULL)
		2199	return NULL;
		2200
		2201	switch (type->kind)
		2202	{
		2203	default:
		2204	return NULL;
		2205	case DEBUG_KIND_POINTER:
		2206	return type->u.kpointer;
		2207	case DEBUG_KIND_REFERENCE:
		2208	return type->u.kreference;
		2209	case DEBUG_KIND_CONST:
		2210	return type->u.kconst;
		2211	case DEBUG_KIND_VOLATILE:
		2212	return type->u.kvolatile;
		2213	}
		2214	/NOTREACHED/
		2215	}
		2216
		2217	/* Get the NULL terminated array of fields for a struct, union, or
		2218	class. */
		2219
		2220	const debug_field *
		2221	debug_get_fields (void *handle, debug_type type)
		2222	{
		2223	if (type == NULL)
		2224	return NULL;
		2225
		2226	type = debug_get_real_type (handle, type, NULL);
		2227	if (type == NULL)
		2228	return NULL;
		2229
		2230	switch (type->kind)
		2231	{
		2232	default:
		2233	return NULL;
		2234	case DEBUG_KIND_STRUCT:
		2235	case DEBUG_KIND_UNION:
		2236	case DEBUG_KIND_CLASS:
		2237	case DEBUG_KIND_UNION_CLASS:
		2238	return type->u.kclass->fields;
		2239	}
		2240	/NOTREACHED/
		2241	}
		2242
		2243	/* Get the type of a field. */
		2244
		2245	debug_type
		2246	debug_get_field_type (void *handle ATTRIBUTE_UNUSED, debug_field field)
		2247	{
		2248	if (field == NULL)
		2249	return NULL;
		2250	return field->type;
		2251	}
		2252
		2253	/* Get the name of a field. */
		2254
		2255	const char *
		2256	debug_get_field_name (void *handle ATTRIBUTE_UNUSED, debug_field field)
		2257	{
		2258	if (field == NULL)
		2259	return NULL;
		2260	return field->name;
		2261	}
		2262
		2263	/* Get the bit position of a field. */
		2264
		2265	bfd_vma
		2266	debug_get_field_bitpos (void *handle ATTRIBUTE_UNUSED, debug_field field)
		2267	{
		2268	if (field == NULL \|\| field->static_member)
		2269	return (bfd_vma) -1;
		2270	return field->u.f.bitpos;
		2271	}
		2272
		2273	/* Get the bit size of a field. */
		2274
		2275	bfd_vma
		2276	debug_get_field_bitsize (void *handle ATTRIBUTE_UNUSED, debug_field field)
		2277	{
		2278	if (field == NULL \|\| field->static_member)
		2279	return (bfd_vma) -1;
		2280	return field->u.f.bitsize;
		2281	}
		2282
		2283	/* Get the visibility of a field. */
		2284
		2285	enum debug_visibility
		2286	debug_get_field_visibility (void *handle ATTRIBUTE_UNUSED, debug_field field)
		2287	{
		2288	if (field == NULL)
		2289	return DEBUG_VISIBILITY_IGNORE;
		2290	return field->visibility;
		2291	}
		2292
		2293	/* Get the physical name of a field. */
		2294
		2295	const char *
		2296	debug_get_field_physname (void *handle ATTRIBUTE_UNUSED, debug_field field)
		2297	{
		2298	if (field == NULL \|\| ! field->static_member)
		2299	return NULL;
		2300	return field->u.s.physname;
		2301	}
		2302
		2303	/* Write out the debugging information. This is given a handle to
		2304	debugging information, and a set of function pointers to call. */
		2305
		2306	bfd_boolean
		2307	debug_write (void handle, const struct debug_write_fns fns, void *fhandle)
		2308	{
		2309	struct debug_handle info = (struct debug_handle ) handle;
		2310	struct debug_unit *u;
		2311
		2312	/* We use a mark to tell whether we have already written out a
		2313	particular name. We use an integer, so that we don't have to
		2314	clear the mark fields if we happen to write out the same
		2315	information more than once. */
		2316	++info->mark;
		2317
		2318	/* The base_id field holds an ID value which will never be used, so
		2319	that we can tell whether we have assigned an ID during this call
		2320	to debug_write. */
		2321	info->base_id = info->class_id;
		2322
		2323	/* We keep a linked list of classes for which was have assigned ID's
		2324	during this call to debug_write. */
		2325	info->id_list = NULL;
		2326
		2327	for (u = info->units; u != NULL; u = u->next)
		2328	{
		2329	struct debug_file *f;
		2330	bfd_boolean first_file;
		2331
		2332	info->current_write_lineno = u->linenos;
		2333	info->current_write_lineno_index = 0;
		2334
		2335	if (! (*fns->start_compilation_unit) (fhandle, u->files->filename))
		2336	return FALSE;
		2337
		2338	first_file = TRUE;
		2339	for (f = u->files; f != NULL; f = f->next)
		2340	{
		2341	struct debug_name *n;
		2342
		2343	if (first_file)
		2344	first_file = FALSE;
		2345	else if (! (*fns->start_source) (fhandle, f->filename))
		2346	return FALSE;
		2347
		2348	if (f->globals != NULL)
		2349	for (n = f->globals->list; n != NULL; n = n->next)
		2350	if (! debug_write_name (info, fns, fhandle, n))
		2351	return FALSE;
		2352	}
		2353
		2354	/* Output any line number information which hasn't already been
		2355	handled. */
		2356	if (! debug_write_linenos (info, fns, fhandle, (bfd_vma) -1))
		2357	return FALSE;
		2358	}
		2359
		2360	return TRUE;
		2361	}
		2362
		2363	/* Write out an element in a namespace. */
		2364
		2365	static bfd_boolean
		2366	debug_write_name (struct debug_handle *info,
		2367	const struct debug_write_fns fns, void fhandle,
		2368	struct debug_name *n)
		2369	{
		2370	switch (n->kind)
		2371	{
		2372	case DEBUG_OBJECT_TYPE:
		2373	if (! debug_write_type (info, fns, fhandle, n->u.type, n)
		2374	\|\| ! (*fns->typdef) (fhandle, n->name))
		2375	return FALSE;
		2376	return TRUE;
		2377	case DEBUG_OBJECT_TAG:
		2378	if (! debug_write_type (info, fns, fhandle, n->u.tag, n))
		2379	return FALSE;
		2380	return (*fns->tag) (fhandle, n->name);
		2381	case DEBUG_OBJECT_VARIABLE:
		2382	if (! debug_write_type (info, fns, fhandle, n->u.variable->type,
		2383	(struct debug_name *) NULL))
		2384	return FALSE;
		2385	return (*fns->variable) (fhandle, n->name, n->u.variable->kind,
		2386	n->u.variable->val);
		2387	case DEBUG_OBJECT_FUNCTION:
		2388	return debug_write_function (info, fns, fhandle, n->name,
		2389	n->linkage, n->u.function);
		2390	case DEBUG_OBJECT_INT_CONSTANT:
		2391	return (*fns->int_constant) (fhandle, n->name, n->u.int_constant);
		2392	case DEBUG_OBJECT_FLOAT_CONSTANT:
		2393	return (*fns->float_constant) (fhandle, n->name, n->u.float_constant);
		2394	case DEBUG_OBJECT_TYPED_CONSTANT:
		2395	if (! debug_write_type (info, fns, fhandle, n->u.typed_constant->type,
		2396	(struct debug_name *) NULL))
		2397	return FALSE;
		2398	return (*fns->typed_constant) (fhandle, n->name,
		2399	n->u.typed_constant->val);
		2400	default:
		2401	abort ();
		2402	return FALSE;
		2403	}
		2404	/NOTREACHED/
		2405	}
		2406
		2407	/* Write out a type. If the type is DEBUG_KIND_NAMED or
		2408	DEBUG_KIND_TAGGED, then the name argument is the name for which we
		2409	are about to call typedef or tag. If the type is anything else,
		2410	then the name argument is a tag from a DEBUG_KIND_TAGGED type which
		2411	points to this one. */
		2412
		2413	static bfd_boolean
		2414	debug_write_type (struct debug_handle *info,
		2415	const struct debug_write_fns fns, void fhandle,
		2416	struct debug_type_s type, struct debug_name name)
		2417	{
		2418	unsigned int i;
		2419	int is;
		2420	const char *tag = NULL;
		2421
		2422	/* If we have a name for this type, just output it. We only output
		2423	typedef names after they have been defined. We output type tags
		2424	whenever we are not actually defining them. */
		2425	if ((type->kind == DEBUG_KIND_NAMED
		2426	\|\| type->kind == DEBUG_KIND_TAGGED)
		2427	&& (type->u.knamed->name->mark == info->mark
		2428	\|\| (type->kind == DEBUG_KIND_TAGGED
		2429	&& type->u.knamed->name != name)))
		2430	{
		2431	if (type->kind == DEBUG_KIND_NAMED)
		2432	return (*fns->typedef_type) (fhandle, type->u.knamed->name->name);
		2433	else
		2434	{
		2435	struct debug_type_s *real;
		2436	unsigned int id;
		2437
		2438	real = debug_get_real_type ((void *) info, type, NULL);
		2439	if (real == NULL)
		2440	return (*fns->empty_type) (fhandle);
		2441	id = 0;
		2442	if ((real->kind == DEBUG_KIND_STRUCT
		2443	\|\| real->kind == DEBUG_KIND_UNION
		2444	\|\| real->kind == DEBUG_KIND_CLASS
		2445	\|\| real->kind == DEBUG_KIND_UNION_CLASS)
		2446	&& real->u.kclass != NULL)
		2447	{
		2448	if (real->u.kclass->id <= info->base_id)
		2449	{
		2450	if (! debug_set_class_id (info,
		2451	type->u.knamed->name->name,
		2452	real))
		2453	return FALSE;
		2454	}
		2455	id = real->u.kclass->id;
		2456	}
		2457
		2458	return (*fns->tag_type) (fhandle, type->u.knamed->name->name, id,
		2459	real->kind);
		2460	}
		2461	}
		2462
		2463	/* Mark the name after we have already looked for a known name, so
		2464	that we don't just define a type in terms of itself. We need to
		2465	mark the name here so that a struct containing a pointer to
		2466	itself will work. */
		2467	if (name != NULL)
		2468	name->mark = info->mark;
		2469
		2470	if (name != NULL
		2471	&& type->kind != DEBUG_KIND_NAMED
		2472	&& type->kind != DEBUG_KIND_TAGGED)
		2473	{
		2474	assert (name->kind == DEBUG_OBJECT_TAG);
		2475	tag = name->name;
		2476	}
		2477
		2478	switch (type->kind)
		2479	{
		2480	case DEBUG_KIND_ILLEGAL:
		2481	debug_error (_("debug_write_type: illegal type encountered"));
		2482	return FALSE;
		2483	case DEBUG_KIND_INDIRECT:
		2484	if (*type->u.kindirect->slot == DEBUG_TYPE_NULL)
		2485	return (*fns->empty_type) (fhandle);
		2486	return debug_write_type (info, fns, fhandle, *type->u.kindirect->slot,
		2487	name);
		2488	case DEBUG_KIND_VOID:
		2489	return (*fns->void_type) (fhandle);
		2490	case DEBUG_KIND_INT:
		2491	return (*fns->int_type) (fhandle, type->size, type->u.kint);
		2492	case DEBUG_KIND_FLOAT:
		2493	return (*fns->float_type) (fhandle, type->size);
		2494	case DEBUG_KIND_COMPLEX:
		2495	return (*fns->complex_type) (fhandle, type->size);
		2496	case DEBUG_KIND_BOOL:
		2497	return (*fns->bool_type) (fhandle, type->size);
		2498	case DEBUG_KIND_STRUCT:
		2499	case DEBUG_KIND_UNION:
		2500	if (type->u.kclass != NULL)
		2501	{
		2502	if (type->u.kclass->id <= info->base_id)
		2503	{
		2504	if (! debug_set_class_id (info, tag, type))
		2505	return FALSE;
		2506	}
		2507
		2508	if (info->mark == type->u.kclass->mark)
		2509	{
		2510	/* We are currently outputting this struct, or we have
		2511	already output it. I don't know if this can happen,
		2512	but it can happen for a class. */
		2513	assert (type->u.kclass->id > info->base_id);
		2514	return (*fns->tag_type) (fhandle, tag, type->u.kclass->id,
		2515	type->kind);
		2516	}
		2517	type->u.kclass->mark = info->mark;
		2518	}
		2519
		2520	if (! (*fns->start_struct_type) (fhandle, tag,
		2521	(type->u.kclass != NULL
		2522	? type->u.kclass->id
		2523	: 0),
		2524	type->kind == DEBUG_KIND_STRUCT,
		2525	type->size))
		2526	return FALSE;
		2527	if (type->u.kclass != NULL
		2528	&& type->u.kclass->fields != NULL)
		2529	{
		2530	for (i = 0; type->u.kclass->fields[i] != NULL; i++)
		2531	{
		2532	struct debug_field_s *f;
		2533
		2534	f = type->u.kclass->fields[i];
		2535	if (! debug_write_type (info, fns, fhandle, f->type,
		2536	(struct debug_name *) NULL)
		2537	\|\| ! (*fns->struct_field) (fhandle, f->name, f->u.f.bitpos,
		2538	f->u.f.bitsize, f->visibility))
		2539	return FALSE;
		2540	}
		2541	}
		2542	return (*fns->end_struct_type) (fhandle);
		2543	case DEBUG_KIND_CLASS:
		2544	case DEBUG_KIND_UNION_CLASS:
		2545	return debug_write_class_type (info, fns, fhandle, type, tag);
		2546	case DEBUG_KIND_ENUM:
		2547	if (type->u.kenum == NULL)
		2548	return (fns->enum_type) (fhandle, tag, (const char *) NULL,
		2549	(bfd_signed_vma *) NULL);
		2550	return (*fns->enum_type) (fhandle, tag, type->u.kenum->names,
		2551	type->u.kenum->values);
		2552	case DEBUG_KIND_POINTER:
		2553	if (! debug_write_type (info, fns, fhandle, type->u.kpointer,
		2554	(struct debug_name *) NULL))
		2555	return FALSE;
		2556	return (*fns->pointer_type) (fhandle);
		2557	case DEBUG_KIND_FUNCTION:
		2558	if (! debug_write_type (info, fns, fhandle,
		2559	type->u.kfunction->return_type,
		2560	(struct debug_name *) NULL))
		2561	return FALSE;
		2562	if (type->u.kfunction->arg_types == NULL)
		2563	is = -1;
		2564	else
		2565	{
		2566	for (is = 0; type->u.kfunction->arg_types[is] != NULL; is++)
		2567	if (! debug_write_type (info, fns, fhandle,
		2568	type->u.kfunction->arg_types[is],
		2569	(struct debug_name *) NULL))
		2570	return FALSE;
		2571	}
		2572	return (*fns->function_type) (fhandle, is,
		2573	type->u.kfunction->varargs);
		2574	case DEBUG_KIND_REFERENCE:
		2575	if (! debug_write_type (info, fns, fhandle, type->u.kreference,
		2576	(struct debug_name *) NULL))
		2577	return FALSE;
		2578	return (*fns->reference_type) (fhandle);
		2579	case DEBUG_KIND_RANGE:
		2580	if (! debug_write_type (info, fns, fhandle, type->u.krange->type,
		2581	(struct debug_name *) NULL))
		2582	return FALSE;
		2583	return (*fns->range_type) (fhandle, type->u.krange->lower,
		2584	type->u.krange->upper);
		2585	case DEBUG_KIND_ARRAY:
		2586	if (! debug_write_type (info, fns, fhandle, type->u.karray->element_type,
		2587	(struct debug_name *) NULL)
		2588	\|\| ! debug_write_type (info, fns, fhandle,
		2589	type->u.karray->range_type,
		2590	(struct debug_name *) NULL))
		2591	return FALSE;
		2592	return (*fns->array_type) (fhandle, type->u.karray->lower,
		2593	type->u.karray->upper,
		2594	type->u.karray->stringp);
		2595	case DEBUG_KIND_SET:
		2596	if (! debug_write_type (info, fns, fhandle, type->u.kset->type,
		2597	(struct debug_name *) NULL))
		2598	return FALSE;
		2599	return (*fns->set_type) (fhandle, type->u.kset->bitstringp);
		2600	case DEBUG_KIND_OFFSET:
		2601	if (! debug_write_type (info, fns, fhandle, type->u.koffset->base_type,
		2602	(struct debug_name *) NULL)
		2603	\|\| ! debug_write_type (info, fns, fhandle,
		2604	type->u.koffset->target_type,
		2605	(struct debug_name *) NULL))
		2606	return FALSE;
		2607	return (*fns->offset_type) (fhandle);
		2608	case DEBUG_KIND_METHOD:
		2609	if (! debug_write_type (info, fns, fhandle,
		2610	type->u.kmethod->return_type,
		2611	(struct debug_name *) NULL))
		2612	return FALSE;
		2613	if (type->u.kmethod->arg_types == NULL)
		2614	is = -1;
		2615	else
		2616	{
		2617	for (is = 0; type->u.kmethod->arg_types[is] != NULL; is++)
		2618	if (! debug_write_type (info, fns, fhandle,
		2619	type->u.kmethod->arg_types[is],
		2620	(struct debug_name *) NULL))
		2621	return FALSE;
		2622	}
		2623	if (type->u.kmethod->domain_type != NULL)
		2624	{
		2625	if (! debug_write_type (info, fns, fhandle,
		2626	type->u.kmethod->domain_type,
		2627	(struct debug_name *) NULL))
		2628	return FALSE;
		2629	}
		2630	return (*fns->method_type) (fhandle,
		2631	type->u.kmethod->domain_type != NULL,
		2632	is,
		2633	type->u.kmethod->varargs);
		2634	case DEBUG_KIND_CONST:
		2635	if (! debug_write_type (info, fns, fhandle, type->u.kconst,
		2636	(struct debug_name *) NULL))
		2637	return FALSE;
		2638	return (*fns->const_type) (fhandle);
		2639	case DEBUG_KIND_VOLATILE:
		2640	if (! debug_write_type (info, fns, fhandle, type->u.kvolatile,
		2641	(struct debug_name *) NULL))
		2642	return FALSE;
		2643	return (*fns->volatile_type) (fhandle);
		2644	case DEBUG_KIND_NAMED:
		2645	return debug_write_type (info, fns, fhandle, type->u.knamed->type,
		2646	(struct debug_name *) NULL);
		2647	case DEBUG_KIND_TAGGED:
		2648	return debug_write_type (info, fns, fhandle, type->u.knamed->type,
		2649	type->u.knamed->name);
		2650	default:
		2651	abort ();
		2652	return FALSE;
		2653	}
		2654	}
		2655
		2656	/* Write out a class type. */
		2657
		2658	static bfd_boolean
		2659	debug_write_class_type (struct debug_handle *info,
		2660	const struct debug_write_fns fns, void fhandle,
		2661	struct debug_type_s type, const char tag)
		2662	{
		2663	unsigned int i;
		2664	unsigned int id;
		2665	struct debug_type_s *vptrbase;
		2666
		2667	if (type->u.kclass == NULL)
		2668	{
		2669	id = 0;
		2670	vptrbase = NULL;
		2671	}
		2672	else
		2673	{
		2674	if (type->u.kclass->id <= info->base_id)
		2675	{
		2676	if (! debug_set_class_id (info, tag, type))
		2677	return FALSE;
		2678	}
		2679
		2680	if (info->mark == type->u.kclass->mark)
		2681	{
		2682	/* We are currently outputting this class, or we have
		2683	already output it. This can happen when there are
		2684	methods for an anonymous class. */
		2685	assert (type->u.kclass->id > info->base_id);
		2686	return (*fns->tag_type) (fhandle, tag, type->u.kclass->id,
		2687	type->kind);
		2688	}
		2689	type->u.kclass->mark = info->mark;
		2690	id = type->u.kclass->id;
		2691
		2692	vptrbase = type->u.kclass->vptrbase;
		2693	if (vptrbase != NULL && vptrbase != type)
		2694	{
		2695	if (! debug_write_type (info, fns, fhandle, vptrbase,
		2696	(struct debug_name *) NULL))
		2697	return FALSE;
		2698	}
		2699	}
		2700
		2701	if (! (*fns->start_class_type) (fhandle, tag, id,
		2702	type->kind == DEBUG_KIND_CLASS,
		2703	type->size,
		2704	vptrbase != NULL,
		2705	vptrbase == type))
		2706	return FALSE;
		2707
		2708	if (type->u.kclass != NULL)
		2709	{
		2710	if (type->u.kclass->fields != NULL)
		2711	{
		2712	for (i = 0; type->u.kclass->fields[i] != NULL; i++)
		2713	{
		2714	struct debug_field_s *f;
		2715
		2716	f = type->u.kclass->fields[i];
		2717	if (! debug_write_type (info, fns, fhandle, f->type,
		2718	(struct debug_name *) NULL))
		2719	return FALSE;
		2720	if (f->static_member)
		2721	{
		2722	if (! (*fns->class_static_member) (fhandle, f->name,
		2723	f->u.s.physname,
		2724	f->visibility))
		2725	return FALSE;
		2726	}
		2727	else
		2728	{
		2729	if (! (*fns->struct_field) (fhandle, f->name, f->u.f.bitpos,
		2730	f->u.f.bitsize, f->visibility))
		2731	return FALSE;
		2732	}
		2733	}
		2734	}
		2735
		2736	if (type->u.kclass->baseclasses != NULL)
		2737	{
		2738	for (i = 0; type->u.kclass->baseclasses[i] != NULL; i++)
		2739	{
		2740	struct debug_baseclass_s *b;
		2741
		2742	b = type->u.kclass->baseclasses[i];
		2743	if (! debug_write_type (info, fns, fhandle, b->type,
		2744	(struct debug_name *) NULL))
		2745	return FALSE;
		2746	if (! (*fns->class_baseclass) (fhandle, b->bitpos, b->is_virtual,
		2747	b->visibility))
		2748	return FALSE;
		2749	}
		2750	}
		2751
		2752	if (type->u.kclass->methods != NULL)
		2753	{
		2754	for (i = 0; type->u.kclass->methods[i] != NULL; i++)
		2755	{
		2756	struct debug_method_s *m;
		2757	unsigned int j;
		2758
		2759	m = type->u.kclass->methods[i];
		2760	if (! (*fns->class_start_method) (fhandle, m->name))
		2761	return FALSE;
		2762	for (j = 0; m->variants[j] != NULL; j++)
		2763	{
		2764	struct debug_method_variant_s *v;
		2765
		2766	v = m->variants[j];
		2767	if (v->context != NULL)
		2768	{
		2769	if (! debug_write_type (info, fns, fhandle, v->context,
		2770	(struct debug_name *) NULL))
		2771	return FALSE;
		2772	}
		2773	if (! debug_write_type (info, fns, fhandle, v->type,
		2774	(struct debug_name *) NULL))
		2775	return FALSE;
		2776	if (v->voffset != VOFFSET_STATIC_METHOD)
		2777	{
		2778	if (! (*fns->class_method_variant) (fhandle, v->physname,
		2779	v->visibility,
		2780	v->constp,
		2781	v->volatilep,
		2782	v->voffset,
		2783	v->context != NULL))
		2784	return FALSE;
		2785	}
		2786	else
		2787	{
		2788	if (! (*fns->class_static_method_variant) (fhandle,
		2789	v->physname,
		2790	v->visibility,
		2791	v->constp,
		2792	v->volatilep))
		2793	return FALSE;
		2794	}
		2795	}
		2796	if (! (*fns->class_end_method) (fhandle))
		2797	return FALSE;
		2798	}
		2799	}
		2800	}
		2801
		2802	return (*fns->end_class_type) (fhandle);
		2803	}
		2804
		2805	/* Write out information for a function. */
		2806
		2807	static bfd_boolean
		2808	debug_write_function (struct debug_handle *info,
		2809	const struct debug_write_fns fns, void fhandle,
		2810	const char *name, enum debug_object_linkage linkage,
		2811	struct debug_function *function)
		2812	{
		2813	struct debug_parameter *p;
		2814	struct debug_block *b;
		2815
		2816	if (! debug_write_linenos (info, fns, fhandle, function->blocks->start))
		2817	return FALSE;
		2818
		2819	if (! debug_write_type (info, fns, fhandle, function->return_type,
		2820	(struct debug_name *) NULL))
		2821	return FALSE;
		2822
		2823	if (! (*fns->start_function) (fhandle, name,
		2824	linkage == DEBUG_LINKAGE_GLOBAL))
		2825	return FALSE;
		2826
		2827	for (p = function->parameters; p != NULL; p = p->next)
		2828	{
		2829	if (! debug_write_type (info, fns, fhandle, p->type,
		2830	(struct debug_name *) NULL)
		2831	\|\| ! (*fns->function_parameter) (fhandle, p->name, p->kind, p->val))
		2832	return FALSE;
		2833	}
		2834
		2835	for (b = function->blocks; b != NULL; b = b->next)
		2836	{
		2837	if (! debug_write_block (info, fns, fhandle, b))
		2838	return FALSE;
		2839	}
		2840
		2841	return (*fns->end_function) (fhandle);
		2842	}
		2843
		2844	/* Write out information for a block. */
		2845
		2846	static bfd_boolean
		2847	debug_write_block (struct debug_handle *info,
		2848	const struct debug_write_fns fns, void fhandle,
		2849	struct debug_block *block)
		2850	{
		2851	struct debug_name *n;
		2852	struct debug_block *b;
		2853
		2854	if (! debug_write_linenos (info, fns, fhandle, block->start))
		2855	return FALSE;
		2856
		2857	/* I can't see any point to writing out a block with no local
		2858	variables, so we don't bother, except for the top level block. */
		2859	if (block->locals != NULL \|\| block->parent == NULL)
		2860	{
		2861	if (! (*fns->start_block) (fhandle, block->start))
		2862	return FALSE;
		2863	}
		2864
		2865	if (block->locals != NULL)
		2866	{
		2867	for (n = block->locals->list; n != NULL; n = n->next)
		2868	{
		2869	if (! debug_write_name (info, fns, fhandle, n))
		2870	return FALSE;
		2871	}
		2872	}
		2873
		2874	for (b = block->children; b != NULL; b = b->next)
		2875	{
		2876	if (! debug_write_block (info, fns, fhandle, b))
		2877	return FALSE;
		2878	}
		2879
		2880	if (! debug_write_linenos (info, fns, fhandle, block->end))
		2881	return FALSE;
		2882
		2883	if (block->locals != NULL \|\| block->parent == NULL)
		2884	{
		2885	if (! (*fns->end_block) (fhandle, block->end))
		2886	return FALSE;
		2887	}
		2888
		2889	return TRUE;
		2890	}
		2891
		2892	/* Write out line number information up to ADDRESS. */
		2893
		2894	static bfd_boolean
		2895	debug_write_linenos (struct debug_handle *info,
		2896	const struct debug_write_fns fns, void fhandle,
		2897	bfd_vma address)
		2898	{
		2899	while (info->current_write_lineno != NULL)
		2900	{
		2901	struct debug_lineno *l;
		2902
		2903	l = info->current_write_lineno;
		2904
		2905	while (info->current_write_lineno_index < DEBUG_LINENO_COUNT)
		2906	{
		2907	if (l->linenos[info->current_write_lineno_index]
		2908	== (unsigned long) -1)
		2909	break;
		2910
		2911	if (l->addrs[info->current_write_lineno_index] >= address)
		2912	return TRUE;
		2913
		2914	if (! (*fns->lineno) (fhandle, l->file->filename,
		2915	l->linenos[info->current_write_lineno_index],
		2916	l->addrs[info->current_write_lineno_index]))
		2917	return FALSE;
		2918
		2919	++info->current_write_lineno_index;
		2920	}
		2921
		2922	info->current_write_lineno = l->next;
		2923	info->current_write_lineno_index = 0;
		2924	}
		2925
		2926	return TRUE;
		2927	}
		2928
		2929	/* Get the ID number for a class. If during the same call to
		2930	debug_write we find a struct with the same definition with the same
		2931	name, we use the same ID. This type of things happens because the
		2932	same struct will be defined by multiple compilation units. */
		2933
		2934	static bfd_boolean
		2935	debug_set_class_id (struct debug_handle info, const char tag,
		2936	struct debug_type_s *type)
		2937	{
		2938	struct debug_class_type *c;
		2939	struct debug_class_id *l;
		2940
		2941	assert (type->kind == DEBUG_KIND_STRUCT
		2942	\|\| type->kind == DEBUG_KIND_UNION
		2943	\|\| type->kind == DEBUG_KIND_CLASS
		2944	\|\| type->kind == DEBUG_KIND_UNION_CLASS);
		2945
		2946	c = type->u.kclass;
		2947
		2948	if (c->id > info->base_id)
		2949	return TRUE;
		2950
		2951	for (l = info->id_list; l != NULL; l = l->next)
		2952	{
		2953	if (l->type->kind != type->kind)
		2954	continue;
		2955
		2956	if (tag == NULL)
		2957	{
		2958	if (l->tag != NULL)
		2959	continue;
		2960	}
		2961	else
		2962	{
		2963	if (l->tag == NULL
		2964	\|\| l->tag[0] != tag[0]
		2965	\|\| strcmp (l->tag, tag) != 0)
		2966	continue;
		2967	}
		2968
		2969	if (debug_type_samep (info, l->type, type))
		2970	{
		2971	c->id = l->type->u.kclass->id;
		2972	return TRUE;
		2973	}
		2974	}
		2975
		2976	/* There are no identical types. Use a new ID, and add it to the
		2977	list. */
		2978	++info->class_id;
		2979	c->id = info->class_id;
		2980
		2981	l = (struct debug_class_id ) xmalloc (sizeof l);
		2982	memset (l, 0, sizeof *l);
		2983
		2984	l->type = type;
		2985	l->tag = tag;
		2986
		2987	l->next = info->id_list;
		2988	info->id_list = l;
		2989
		2990	return TRUE;
		2991	}
		2992
		2993	/* See if two types are the same. At this point, we don't care about
		2994	tags and the like. */
		2995
		2996	static bfd_boolean
		2997	debug_type_samep (struct debug_handle info, struct debug_type_s t1,
		2998	struct debug_type_s *t2)
		2999	{
		3000	struct debug_type_compare_list *l;
		3001	struct debug_type_compare_list top;
		3002	bfd_boolean ret;
		3003
		3004	if (t1 == NULL)
		3005	return t2 == NULL;
		3006	if (t2 == NULL)
		3007	return FALSE;
		3008
		3009	while (t1->kind == DEBUG_KIND_INDIRECT)
		3010	{
		3011	t1 = *t1->u.kindirect->slot;
		3012	if (t1 == NULL)
		3013	return FALSE;
		3014	}
		3015	while (t2->kind == DEBUG_KIND_INDIRECT)
		3016	{
		3017	t2 = *t2->u.kindirect->slot;
		3018	if (t2 == NULL)
		3019	return FALSE;
		3020	}
		3021
		3022	if (t1 == t2)
		3023	return TRUE;
		3024
		3025	/* As a special case, permit a typedef to match a tag, since C++
		3026	debugging output will sometimes add a typedef where C debugging
		3027	output will not. */
		3028	if (t1->kind == DEBUG_KIND_NAMED
		3029	&& t2->kind == DEBUG_KIND_TAGGED)
		3030	return debug_type_samep (info, t1->u.knamed->type, t2);
		3031	else if (t1->kind == DEBUG_KIND_TAGGED
		3032	&& t2->kind == DEBUG_KIND_NAMED)
		3033	return debug_type_samep (info, t1, t2->u.knamed->type);
		3034
		3035	if (t1->kind != t2->kind
		3036	\|\| t1->size != t2->size)
		3037	return FALSE;
		3038
		3039	/* Get rid of the trivial cases first. */
		3040	switch (t1->kind)
		3041	{
		3042	default:
		3043	break;
		3044	case DEBUG_KIND_VOID:
		3045	case DEBUG_KIND_FLOAT:
		3046	case DEBUG_KIND_COMPLEX:
		3047	case DEBUG_KIND_BOOL:
		3048	return TRUE;
		3049	case DEBUG_KIND_INT:
		3050	return t1->u.kint == t2->u.kint;
		3051	}
		3052
		3053	/* We have to avoid an infinite recursion. We do this by keeping a
		3054	list of types which we are comparing. We just keep the list on
		3055	the stack. If we encounter a pair of types we are currently
		3056	comparing, we just assume that they are equal. */
		3057	for (l = info->compare_list; l != NULL; l = l->next)
		3058	{
		3059	if (l->t1 == t1 && l->t2 == t2)
		3060	return TRUE;
		3061	}
		3062
		3063	top.t1 = t1;
		3064	top.t2 = t2;
		3065	top.next = info->compare_list;
		3066	info->compare_list = ⊤
		3067
		3068	switch (t1->kind)
		3069	{
		3070	default:
		3071	abort ();
		3072	ret = FALSE;
		3073	break;
		3074
		3075	case DEBUG_KIND_STRUCT:
		3076	case DEBUG_KIND_UNION:
		3077	case DEBUG_KIND_CLASS:
		3078	case DEBUG_KIND_UNION_CLASS:
		3079	if (t1->u.kclass == NULL)
		3080	ret = t2->u.kclass == NULL;
		3081	else if (t2->u.kclass == NULL)
		3082	ret = FALSE;
		3083	else if (t1->u.kclass->id > info->base_id
		3084	&& t1->u.kclass->id == t2->u.kclass->id)
		3085	ret = TRUE;
		3086	else
		3087	ret = debug_class_type_samep (info, t1, t2);
		3088	break;
		3089
		3090	case DEBUG_KIND_ENUM:
		3091	if (t1->u.kenum == NULL)
		3092	ret = t2->u.kenum == NULL;
		3093	else if (t2->u.kenum == NULL)
		3094	ret = FALSE;
		3095	else
		3096	{
		3097	const char pn1, pn2;
		3098	bfd_signed_vma pv1, pv2;
		3099
		3100	pn1 = t1->u.kenum->names;
		3101	pn2 = t2->u.kenum->names;
		3102	pv1 = t1->u.kenum->values;
		3103	pv2 = t2->u.kenum->values;
		3104	while (pn1 != NULL && pn2 != NULL)
		3105	{
		3106	if (pn1 != pn2
		3107	\|\| pv1 != pv2
		3108	\|\| strcmp (pn1, pn2) != 0)
		3109	break;
		3110	++pn1;
		3111	++pn2;
		3112	++pv1;
		3113	++pv2;
		3114	}
		3115	ret = pn1 == NULL && pn2 == NULL;
		3116	}
		3117	break;
		3118
		3119	case DEBUG_KIND_POINTER:
		3120	ret = debug_type_samep (info, t1->u.kpointer, t2->u.kpointer);
		3121	break;
		3122
		3123	case DEBUG_KIND_FUNCTION:
		3124	if (t1->u.kfunction->varargs != t2->u.kfunction->varargs
		3125	\|\| ! debug_type_samep (info, t1->u.kfunction->return_type,
		3126	t2->u.kfunction->return_type)
		3127	\|\| ((t1->u.kfunction->arg_types == NULL)
		3128	!= (t2->u.kfunction->arg_types == NULL)))
		3129	ret = FALSE;
		3130	else if (t1->u.kfunction->arg_types == NULL)
		3131	ret = TRUE;
		3132	else
		3133	{
		3134	struct debug_type_s a1, a2;
		3135
		3136	a1 = t1->u.kfunction->arg_types;
		3137	a2 = t2->u.kfunction->arg_types;
		3138	while (a1 != NULL && a2 != NULL)
		3139	{
		3140	if (! debug_type_samep (info, a1, a2))
		3141	break;
		3142	++a1;
		3143	++a2;
		3144	}
		3145	ret = a1 == NULL && a2 == NULL;
		3146	}
		3147	break;
		3148
		3149	case DEBUG_KIND_REFERENCE:
		3150	ret = debug_type_samep (info, t1->u.kreference, t2->u.kreference);
		3151	break;
		3152
		3153	case DEBUG_KIND_RANGE:
		3154	ret = (t1->u.krange->lower == t2->u.krange->lower
		3155	&& t1->u.krange->upper == t2->u.krange->upper
		3156	&& debug_type_samep (info, t1->u.krange->type,
		3157	t2->u.krange->type));
6324	serge	3158	break;
5217	serge	3159
		3160	case DEBUG_KIND_ARRAY:
		3161	ret = (t1->u.karray->lower == t2->u.karray->lower
		3162	&& t1->u.karray->upper == t2->u.karray->upper
		3163	&& t1->u.karray->stringp == t2->u.karray->stringp
		3164	&& debug_type_samep (info, t1->u.karray->element_type,
		3165	t2->u.karray->element_type));
		3166	break;
		3167
		3168	case DEBUG_KIND_SET:
		3169	ret = (t1->u.kset->bitstringp == t2->u.kset->bitstringp
		3170	&& debug_type_samep (info, t1->u.kset->type, t2->u.kset->type));
		3171	break;
		3172
		3173	case DEBUG_KIND_OFFSET:
		3174	ret = (debug_type_samep (info, t1->u.koffset->base_type,
		3175	t2->u.koffset->base_type)
		3176	&& debug_type_samep (info, t1->u.koffset->target_type,
		3177	t2->u.koffset->target_type));
		3178	break;
		3179
		3180	case DEBUG_KIND_METHOD:
		3181	if (t1->u.kmethod->varargs != t2->u.kmethod->varargs
		3182	\|\| ! debug_type_samep (info, t1->u.kmethod->return_type,
		3183	t2->u.kmethod->return_type)
		3184	\|\| ! debug_type_samep (info, t1->u.kmethod->domain_type,
		3185	t2->u.kmethod->domain_type)
		3186	\|\| ((t1->u.kmethod->arg_types == NULL)
		3187	!= (t2->u.kmethod->arg_types == NULL)))
		3188	ret = FALSE;
		3189	else if (t1->u.kmethod->arg_types == NULL)
		3190	ret = TRUE;
		3191	else
		3192	{
		3193	struct debug_type_s a1, a2;
		3194
		3195	a1 = t1->u.kmethod->arg_types;
		3196	a2 = t2->u.kmethod->arg_types;
		3197	while (a1 != NULL && a2 != NULL)
		3198	{
		3199	if (! debug_type_samep (info, a1, a2))
		3200	break;
		3201	++a1;
		3202	++a2;
		3203	}
		3204	ret = a1 == NULL && a2 == NULL;
		3205	}
		3206	break;
		3207
		3208	case DEBUG_KIND_CONST:
		3209	ret = debug_type_samep (info, t1->u.kconst, t2->u.kconst);
		3210	break;
		3211
		3212	case DEBUG_KIND_VOLATILE:
		3213	ret = debug_type_samep (info, t1->u.kvolatile, t2->u.kvolatile);
		3214	break;
		3215
		3216	case DEBUG_KIND_NAMED:
		3217	case DEBUG_KIND_TAGGED:
		3218	ret = (strcmp (t1->u.knamed->name->name, t2->u.knamed->name->name) == 0
		3219	&& debug_type_samep (info, t1->u.knamed->type,
		3220	t2->u.knamed->type));
		3221	break;
		3222	}
		3223
		3224	info->compare_list = top.next;
		3225
		3226	return ret;
		3227	}
		3228
		3229	/* See if two classes are the same. This is a subroutine of
		3230	debug_type_samep. */
		3231
		3232	static bfd_boolean
		3233	debug_class_type_samep (struct debug_handle info, struct debug_type_s t1,
		3234	struct debug_type_s *t2)
		3235	{
		3236	struct debug_class_type c1, c2;
		3237
		3238	c1 = t1->u.kclass;
		3239	c2 = t2->u.kclass;
		3240
		3241	if ((c1->fields == NULL) != (c2->fields == NULL)
		3242	\|\| (c1->baseclasses == NULL) != (c2->baseclasses == NULL)
		3243	\|\| (c1->methods == NULL) != (c2->methods == NULL)
		3244	\|\| (c1->vptrbase == NULL) != (c2->vptrbase == NULL))
		3245	return FALSE;
		3246
		3247	if (c1->fields != NULL)
		3248	{
		3249	struct debug_field_s pf1, pf2;
		3250
		3251	for (pf1 = c1->fields, pf2 = c2->fields;
		3252	pf1 != NULL && pf2 != NULL;
		3253	pf1++, pf2++)
		3254	{
		3255	struct debug_field_s f1, f2;
		3256
		3257	f1 = *pf1;
		3258	f2 = *pf2;
		3259	if (f1->name[0] != f2->name[0]
		3260	\|\| f1->visibility != f2->visibility
		3261	\|\| f1->static_member != f2->static_member)
		3262	return FALSE;
		3263	if (f1->static_member)
		3264	{
		3265	if (strcmp (f1->u.s.physname, f2->u.s.physname) != 0)
		3266	return FALSE;
		3267	}
		3268	else
		3269	{
		3270	if (f1->u.f.bitpos != f2->u.f.bitpos
		3271	\|\| f1->u.f.bitsize != f2->u.f.bitsize)
		3272	return FALSE;
		3273	}
		3274	/* We do the checks which require function calls last. We
		3275	don't require that the types of fields have the same
		3276	names, since that sometimes fails in the presence of
		3277	typedefs and we really don't care. */
		3278	if (strcmp (f1->name, f2->name) != 0
		3279	\|\| ! debug_type_samep (info,
		3280	debug_get_real_type ((void *) info,
		3281	f1->type, NULL),
		3282	debug_get_real_type ((void *) info,
		3283	f2->type, NULL)))
		3284	return FALSE;
		3285	}
		3286	if (pf1 != NULL \|\| pf2 != NULL)
		3287	return FALSE;
		3288	}
		3289
		3290	if (c1->vptrbase != NULL)
		3291	{
		3292	if (! debug_type_samep (info, c1->vptrbase, c2->vptrbase))
		3293	return FALSE;
		3294	}
		3295
		3296	if (c1->baseclasses != NULL)
		3297	{
		3298	struct debug_baseclass_s pb1, pb2;
		3299
		3300	for (pb1 = c1->baseclasses, pb2 = c2->baseclasses;
		3301	pb1 != NULL && pb2 != NULL;
		3302	++pb1, ++pb2)
		3303	{
		3304	struct debug_baseclass_s b1, b2;
		3305
		3306	b1 = *pb1;
		3307	b2 = *pb2;
		3308	if (b1->bitpos != b2->bitpos
		3309	\|\| b1->is_virtual != b2->is_virtual
		3310	\|\| b1->visibility != b2->visibility
		3311	\|\| ! debug_type_samep (info, b1->type, b2->type))
		3312	return FALSE;
		3313	}
		3314	if (pb1 != NULL \|\| pb2 != NULL)
		3315	return FALSE;
		3316	}
		3317
		3318	if (c1->methods != NULL)
		3319	{
		3320	struct debug_method_s pm1, pm2;
		3321
		3322	for (pm1 = c1->methods, pm2 = c2->methods;
		3323	pm1 != NULL && pm2 != NULL;
		3324	++pm1, ++pm2)
		3325	{
		3326	struct debug_method_s m1, m2;
		3327
		3328	m1 = *pm1;
		3329	m2 = *pm2;
		3330	if (m1->name[0] != m2->name[0]
		3331	\|\| strcmp (m1->name, m2->name) != 0
		3332	\|\| (m1->variants == NULL) != (m2->variants == NULL))
		3333	return FALSE;
		3334	if (m1->variants == NULL)
		3335	{
		3336	struct debug_method_variant_s pv1, pv2;
		3337
		3338	for (pv1 = m1->variants, pv2 = m2->variants;
		3339	pv1 != NULL && pv2 != NULL;
		3340	++pv1, ++pv2)
		3341	{
		3342	struct debug_method_variant_s v1, v2;
		3343
		3344	v1 = *pv1;
		3345	v2 = *pv2;
		3346	if (v1->physname[0] != v2->physname[0]
		3347	\|\| v1->visibility != v2->visibility
		3348	\|\| v1->constp != v2->constp
		3349	\|\| v1->volatilep != v2->volatilep
		3350	\|\| v1->voffset != v2->voffset
		3351	\|\| (v1->context == NULL) != (v2->context == NULL)
		3352	\|\| strcmp (v1->physname, v2->physname) != 0
		3353	\|\| ! debug_type_samep (info, v1->type, v2->type))
		3354	return FALSE;
		3355	if (v1->context != NULL)
		3356	{
		3357	if (! debug_type_samep (info, v1->context,
		3358	v2->context))
		3359	return FALSE;
		3360	}
		3361	}
		3362	if (pv1 != NULL \|\| pv2 != NULL)
		3363	return FALSE;
		3364	}
		3365	}
		3366	if (pm1 != NULL \|\| pm2 != NULL)
		3367	return FALSE;
		3368	}
		3369
		3370	return TRUE;
		3371	}

Subversion Repositories Kolibri OS

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