WebSVN – tendra.SVN – Blame – /branches/tendra4/src/installers/sparc/solaris/sparcdiags.c

Rev	Author	Line No.	Line
2	7u83	1	`/*`
		2	`Crown Copyright (c) 1997`
		3
		4	`This TenDRA(r) Computer Program is subject to Copyright`
		5	`owned by the United Kingdom Secretary of State for Defence`
		6	`acting through the Defence Evaluation and Research Agency`
		7	`(DERA). It is made available to Recipients with a`
		8	`royalty-free licence for its use, reproduction, transfer`
		9	`to other parties and amendment for any purpose not excluding`
		10	`product development provided that any such use et cetera`
		11	`shall be deemed to be acceptance of the following conditions:-`
		12
		13	`(1) Its Recipients shall ensure that this Notice is`
		14	`reproduced upon any copies or amended versions of it;`
		15
		16	`(2) Any amended version of it shall be clearly marked to`
		17	`show both the nature of and the organisation responsible`
		18	`for the relevant amendment or amendments;`
		19
		20	`(3) Its onward transfer from a recipient to another`
		21	`party shall be deemed to be that party's acceptance of`
		22	`these conditions;`
		23
		24	`(4) DERA gives no warranty or assurance as to its`
		25	`quality or suitability for any purpose and DERA accepts`
		26	`no liability whatsoever in relation to any use to which`
		27	`it may be put.`
		28	`*/`
		29
		30
		31
		32
		33	`/*`
		34	`VERSION INFORMATION`
		35	`===================`
		36
		37	`--------------------------------------------------------------------------`
		38	$Header: /u/g/release/CVSROOT/Source/src/installers/sparc/solaris/sparcdiags.c,v 1.3 1998/03/11 11:04:07 pwe Exp $
		39	`--------------------------------------------------------------------------`
		40	$Log: sparcdiags.c,v $
		41	`* Revision 1.3 1998/03/11 11:04:07 pwe`
		42	`* DWARF optimisation info`
		43	`*`
		44	`* Revision 1.2 1998/02/04 15:50:11 pwe`
		45	`* STABS for void*`
		46	`*`
		47	`* Revision 1.1.1.1 1998/01/17 15:55:53 release`
		48	`* First version to be checked into rolling release.`
		49	`*`
		50	`* Revision 1.5 1998/01/09 15:00:12 pwe`
		51	`* prep restructure`
		52	`*`
		53	`* Revision 1.4 1997/08/23 13:55:22 pwe`
		54	`* initial ANDF-DE`
		55	`*`
		56	`* Revision 1.3 1997/04/04 15:23:42 pwe`
		57	`* tidy re old DWARF interface`
		58	`*`
		59	`* Revision 1.2 1997/04/01 17:17:42 pwe`
		60	`* diagnose pl_tests`
		61	`*`
		62	`* Revision 1.1 1997/03/24 17:10:03 pwe`
		63	`* reorganise solaris/sunos split`
		64	`*`
		65	`* Revision 1.11 1997/02/18 11:48:22 pwe`
		66	`* NEWDIAGS for debugging optimised code`
		67	`*`
		68	`* Revision 1.10 1996/09/10 14:36:55 pwe`
		69	`* fix diags - nested scope, param struct and leaf return`
		70	`*`
		71	`* Revision 1.9 1996/09/09 08:39:55 pwe`
		72	`* correct stabs enums`
		73	`*`
		74	`* Revision 1.8 1995/12/15 10:27:23 john`
		75	`* Fixed error in previous fix`
		76	`*`
		77	`* Revision 1.7 1995/11/23 15:21:31 john`
		78	`* Fix for diagnostics (nested structures)`
		79	`*`
		80	`* Revision 1.6 1995/07/03 09:30:13 john`
		81	`* Fixed error`
		82	`*`
		83	`* Revision 1.5 1995/06/29 08:20:22 john`
		84	`* Reformatting`
		85	`*`
		86	`* Revision 1.4 1995/06/27 08:47:38 john`
		87	`* Some reformatting`
		88	`*`
		89	`* Revision 1.3 1995/04/20 08:06:36 john`
		90	`* Minor change`
		91	`*`
		92	`* Revision 1.2 1995/03/27 12:50:40 john`
		93	`* Fix for c-style varargs handling`
		94	`*`
		95	`* Revision 1.1.1.1 1995/03/13 10:18:56 john`
		96	`* Entered into CVS`
		97	`*`
		98	`* Revision 1.7 1995/01/11 16:40:35 john`
		99	`* Fixed bug in diagnostics (for change request CR95_40)`
		100	`*`
		101	`* Revision 1.6 1995/01/11 09:59:32 john`
		102	`* Fixed bug in diagnostics (for change request CR94_224)`
		103	`*`
		104	`* Revision 1.5 1994/07/07 16:11:33 djch`
		105	`* Jul94 tape`
		106	`*`
		107	`* Revision 1.4 1994/07/04 08:29:06 djch`
		108	`* added extra parameter to stabd (section number). -ve values used to control`
		109	`* not putting out stabd (sometimes) in solaris; line #s go in the stabs.`
		110	`* added assert(0) to catch uninitialized items.`
		111	`*`
		112	`* Revision 1.3 1994/06/22 09:48:33 djch`
		113	`* Changes for solaris - line #s in functions are relative to start of fns,`
		114	`* global decls have line # in the stabs, and no stabn, and local labels are .LL,`
		115	`* not LL`
		116	`*`
		117	`* Revision 1.2 1994/05/13 13:08:39 djch`
		118	`* Incorporates improvements from expt version`
		119	`* changed format strings to remove longs..`
		120	`*`
		121	`* Revision 1.1 1994/05/03 14:49:53 djch`
		122	`* Initial revision`
		123	`*`
		124	`* Revision 1.6 93/09/27 14:55:15 14:55:15 ra (Robert Andrews)`
		125	`* Only whitespace.`
		126	`*`
		127	`* Revision 1.5 93/08/27 11:37:55 11:37:55 ra (Robert Andrews)`
		128	`* A couple of lint-like changes.`
		129	`*`
		130	`* Revision 1.4 93/08/13 14:45:51 14:45:51 ra (Robert Andrews)`
		131	`* Allow the stabs for long double to vary depending on DOUBLE_SZ.`
		132	`*`
		133	`* Revision 1.3 93/07/05 18:26:29 18:26:29 ra (Robert Andrews)`
		134	`* A couple of minor corrections. Introduced stab_ptrs to avoid duplication`
		135	`* of basic pointer types.`
		136	`*`
		137	`* Revision 1.2 93/06/29 14:32:54 14:32:54 ra (Robert Andrews)`
		138	`* Fairly major rewrite and reformat. There were a number of errors which`
		139	`* meant that the diagnostics were not previously working.`
		140	`*`
		141	`* Revision 1.1 93/06/24 14:59:22 14:59:22 ra (Robert Andrews)`
		142	`* Initial revision`
		143	`*`
		144	`--------------------------------------------------------------------------`
		145	`*/`
		146
		147
		148	`#define SPARCTRANS_CODE`
		149	`#include "config.h"`
		150	`#include "addrtypes.h"`
		151	`#include "exptypes.h"`
		152	`#include "shapemacs.h"`
		153	`#include "expmacs.h"`
		154	`#include "codetypes.h"`
		155	`#include "installtypes.h"`
		156	`#include "toktypes.h"`
		157	`#include "exp.h"`
		158	`#include "exptypes.h"`
		159	`#include "proctypes.h"`
		160	`#include "procrec.h"`
		161	`#include "tags.h"`
		162	`#include "bitsmacs.h"`
		163	`#include "xalloc.h"`
		164	`#include "locate.h"`
		165	`#include "comment.h"`
		166	`#include "myassert.h"`
		167	`#include "translat.h"`
		168	`#include "machine.h"`
		169	`#include "szs_als.h"`
		170	`#include "read_fns.h"`
		171	`#include "installglob.h"`
		172	`#include "externs.h"`
		173	`#include "out.h"`
		174	`#include "sparcdiags.h"`
		175	`#include "basicread.h"`
		176
		177	`#ifdef NEWDIAGS`
		178
		179	`#include "dg_types.h"`
		180	`#include "dg_aux.h"`
		181	`#include "dg_globs.h"`
		182	`/* #include "proc.h" */`
		183	`/* #include "regmacs.h" */`
		184
		185	`#else`
		186
		187	`#include "diagtypes.h"`
		188	`#include "diag_fns.h"`
		189	`#include "mark_scope.h"`
		190	`#include "diagglob.h"`
		191
		192	`#endif`
		193
		194	`extern bool last_param PROTO_S ( ( exp ) ) ;`
		195
		196
		197	`#if 0`
		198
		199	`void init_stab`
		200	`PROTO_Z ()`
		201	`{`
		202	`return;`
		203	`}`
		204
		205	`void init_stab_aux`
		206	`PROTO_Z ()`
		207	`{`
		208	`return;`
		209	`}`
		210
		211	`#endif`
		212
		213
		214	`/*`
		215	`FORWARD DECLARATIONS`
		216	`*/`
		217
		218	`#ifdef NEWDIAGS`
		219
		220	`static void stab_file PROTO_S ( ( dg_filename ) ) ;`
		221	`static void stab_scope_open PROTO_S ( ( dg_filename ) ) ;`
		222	`static void stab_scope_close PROTO_S ( ( void ) ) ;`
		223	`static void out_dt_shape PROTO_S ( ( dg_type ) ) ;`
		224	`static void stab_local PROTO_S ( ( dg_name, int ) ) ;`
		225
		226	`#else`
		227
		228	`static void stab_scope_open PROTO_S ( ( long ) ) ;`
		229	`static void stab_scope_close PROTO_S ( ( void ) ) ;`
		230
		231	`#endif`
		232
		233
		234
		235	`/*`
		236	`DIAGNOSTICS FILE`
		237	`*/`
		238
		239	`static FILE *dg_file ;`
		240
		241	`#ifndef NEWDIAGS`
		242	`static char *dg_file_name ;`
		243	`#endif`
		244
		245
		246	`/* label number sequence independent from text code */`
		247
		248	`static int diag_lab_no = 0;`
		249
		250	`static int next_d_lab`
		251	`PROTO_Z ()`
		252	`{`
		253	`return ++diag_lab_no;`
		254	`}`
		255
		256
		257
		258	`/*`
		259	`BASIC TYPE NUMBERS`
		260	`*/`
		261
		262	`#define STAB_SCHAR 4`
		263	`#define STAB_UCHAR 6`
		264	`#define STAB_SSHRT 2`
		265	`#define STAB_USHRT 3`
		266	`#define STAB_SLONG 7`
		267	`#define STAB_ULONG 9`
		268	`#define STAB_SINT 1`
		269	`#define STAB_UINT 8`
		270	`#define STAB_FLOAT 10`
		271	`#define STAB_DBL 11`
		272	`#define STAB_LDBL 12`
		273	`#define STAB_VOID 13`
		274	`#define STAB_S64 14`
		275	`#define STAB_U64 15`
		276	`#define STAB_VS 16`
		277	`#define NO_STABS 17`
		278
		279
		280	`/*`
		281	`BASIC POINTERS`
		282	`*/`
		283
		284	`static long stab_ptrs [ NO_STABS ] = {`
		285	`0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0`
		286	`} ;`
		287
		288
		289	`/*`
		290	`CURRENT TYPE NUMBER`
		291	`*/`
		292
		293	`static long typeno ;`
		294
		295
		296	`/*`
		297	`SIZE OF LAST STAB TYPE OUTPUT`
		298	`*/`
		299
		300	`static long last_type_sz = 0 ;`
		301
		302
		303	`/*`
		304	`CURRENT LINE NUMBER AND FILE NUMBER`
		305	`*/`
		306
		307	`long currentlno = -1 ;`
		308
		309	`#ifdef NEWDIAGS`
		310
		311	`dg_filename currentfile = (dg_filename)0;`
		312	`dg_filename prim_file = (dg_filename)0;`
		313
		314	`#else`
		315
		316	`long currentfile = -1 ;`
		317
		318	`#endif`
		319
		320
		321	`/*`
		322	`ARRAY OF TYPE SIZES`
		323	`*/`
		324
		325	`static long *type_sizes ;`
		326	`static int total_type_sizes = 0 ;`
		327
		328
		329	`/*`
		330	`SETTING AND GETTING TYPE SIZES`
		331	`*/`
		332
		333	`#define set_stab_size( i ) type_sizes [ ( i ) ] = last_type_sz`
		334	`#define get_stab_size( i ) ( type_sizes [ ( i ) ] )`
		335	`#define shape_stab_size( i, s ) type_sizes [ ( i ) ] = shape_size (s)`
		336
		337
		338	`/*`
		339	`GET THE NEXT TYPE NUMBER`
		340	`*/`
		341
		342	`static long next_typen`
		343	`PROTO_Z ()`
		344	`{`
		345	`if ( typeno >= total_type_sizes ) {`
		346	`int i, n = total_type_sizes, m = n + 100 ;`
		347	`type_sizes = ( long * ) xrealloc ( type_sizes, (size_t)m * sizeof ( long ) ) ;`
		348	`for ( i = n ; i < m ; i++ ) type_sizes [i] = 0 ;`
		349	`total_type_sizes = m ;`
		350	`}`
		351	`return ( typeno++ ) ;`
		352	`}`
		353
		354
		355	`#ifndef NEWDIAGS`
		356
		357	`/*`
		358	`ARRAY OF FILE DESCRIPTORS`
		359	`*/`
		360
		361	`static filename *fds = null ;`
		362	`static int szfds = 0 ;`
		363	`static int nofds = 0 ;`
		364
		365
		366	`/*`
		367	`ADD A NEW FILE TO THE ARRAY OF FILE DESCRIPTORS`
		368	`*/`
		369
		370	`void stab_collect_files`
		371	`PROTO_N ( ( f ) )`
		372	`PROTO_T ( filename f )`
		373	`{`
		374	`if ( fds == null ) {`
		375	`szfds += 10 ;`
		376	`fds = ( filename * ) xmalloc ( szfds * sizeof ( filename ) ) ;`
		377	`}`
		378	`else if ( nofds >= szfds ) {`
		379	`szfds += 10 ;`
		380	`fds = ( filename * ) xrealloc ( fds, szfds * sizeof ( filename ) ) ;`
		381	`}`
		382	`fds [ nofds++ ] = f ;`
		383	`return ;`
		384	`}`
		385
		386
		387	`/*`
		388	`FIND THE FILE DESCRIPTOR CORRESPONDING TO A FILE NAME`
		389	`*/`
		390
		391	`static long find_file`
		392	`PROTO_N ( ( f ) )`
		393	`PROTO_T ( char * f )`
		394	`{`
		395	`long i ;`
		396	`for ( i = 0 ; i < nofds ; i++ ) {`
		397	`if ( strcmp ( f, fds [i]->file.ints.chars ) == 0 ) return ( i ) ;`
		398	`}`
		399	`return ( 0 ) ;`
		400	`}`
		401
		402	`#endif`
		403
		404
		405	`/* solaris stores line no's relative`
		406	`to the start of the procedure, so`
		407	`remember the name */`
		408	`static char * last_proc_lab = "<<No Proc>>";`
		409
		410	`/*`
		411	`OUTPUT A FILE POSITION CONSTRUCT`
		412	`*/`
		413
		414	`#define N_SLINE 0x44`
		415	`#define N_DSLINE 0x46`
		416	`#define N_BSLINE 0x48`
		417	`#define N_LBRAC 0xc0`
		418	`#define N_RBRAC 0xe0`
		419
		420	`#ifdef NEWDIAGS`
		421
		422	`void stabd`
		423	`PROTO_N ( ( f, lno, seg ) )`
		424	`PROTO_T ( dg_filename f X long lno X int seg )`
		425	`{`
		426	`long i ;`
		427	`if ( f == currentfile && lno == currentlno ) return ;`
		428	`stab_file ( f ) ;`
		429
		430	`if (seg != 0){ /* 0 suppresses always */`
		431
		432	`if (seg > 0) /* -ve line nos are put out in the stabs */`
		433	`{`
		434	`i = next_d_lab () ;`
		435	`fprintf ( dg_file, "\t.stabn\t0x%x,0,%ld,.LL.%ld-%s\n",seg,`
		436	`lno, i, last_proc_lab ) ;`
		437	`fprintf ( dg_file, ".LL.%ld:\n", i ) ;`
		438	`}`
		439	`}`
		440	`currentlno = lno ;`
		441	`return ;`
		442	`}`
		443
		444	`#else`
		445
		446	`void stabd`
		447	`PROTO_N ( ( findex, lno, seg ) )`
		448	`PROTO_T ( long findex X long lno X int seg )`
		449	`{`
		450	`long i ;`
		451	`if ( findex == currentfile && lno == currentlno ) return ;`
		452	`stab_file ( findex, 1 ) ;`
		453
		454	`if (seg != 0){ /* 0 suppresses always */`
		455
		456	`if (seg > 0) /* -ve line nos are put out in the stabs */`
		457	`{`
		458	`i = next_d_lab () ;`
		459	`fprintf ( dg_file, "\t.stabn\t0x%x,0,%ld,.LL.%ld-%s\n",seg,`
		460	`lno, i, last_proc_lab ) ;`
		461	`fprintf ( dg_file, ".LL.%ld:\n", i ) ;`
		462	`}`
		463	`}`
		464	`currentlno = lno ;`
		465	`return ;`
		466	`}`
		467
		468	`#endif`
		469
		470
		471	`#ifdef NEWDIAGS`
		472	`/*`
		473	`OUTPUT DIAGNOSTICS SURROUNDING CODE`
		474	`*/`
		475
		476	`void code_diag_info`
		477	`PROTO_N ( (d, mcode, args) )`
		478	`PROTO_T ( dg_info d X void (mcode) PROTO_S ((void )) X void * args )`
		479	`{`
		480	`if (d == nildiag) {`
		481	`(*mcode)(args);`
		482	`return;`
		483	`}`
		484	`switch (d->key) {`
		485	`case DGA_PARAMS: {`
		486	`dg_name arg = d->data.i_param.args;`
		487	`while (arg) {`
		488	`stab_local (arg, 1);`
		489	`arg = arg->next;`
		490	`}`
		491	`code_diag_info (d->more, mcode, args);`
		492	`break;`
		493	`}`
		494	`case DGA_SRC: {`
		495	`if (d->data.i_src.startpos.line) {`
		496	`stabd ( d->data.i_src.startpos.file, d->data.i_src.startpos.line,`
		497	`N_SLINE ) ;`
		498	`}`
		499	`code_diag_info (d->more, mcode, args);`
		500	`if (d->data.i_src.endpos.line)`
		501	`stabd ( d->data.i_src.endpos.file, d->data.i_src.endpos.line,`
		502	`N_SLINE ) ;`
		503	`break;`
		504	`}`
		505	`case DGA_SCOPE:`
		506	`case DGA_EXTRA: {`
		507	`dg_filename f = currentfile;`
		508	`long l = currentlno + 1;`
		509	`if (d->data.i_scope.lexpos.line) {`
		510	`f = d->data.i_scope.lexpos.file;`
		511	`l = d->data.i_scope.lexpos.line;`
		512	`}`
		513	`stab_scope_open ( f ) ;`
		514	`stabd ( f, l, N_SLINE ) ;`
		515	`code_diag_info (d->more, mcode, args);`
		516	`stab_scope_close () ;`
		517	`if (d->data.i_scope.endpos.line)`
		518	`stabd ( d->data.i_scope.endpos.file, d->data.i_scope.endpos.line,`
		519	`N_SLINE ) ;`
		520	`break;`
		521	`}`
		522	`case DGA_NAME: {`
		523	`stab_local (d->data.i_nam.dnam, 0);`
		524	`code_diag_info (d->more, mcode, args);`
		525	`break;`
		526	`}`
		527	`default: {`
		528	`code_diag_info (d->more, mcode, args);`
		529	`break;`
		530	`}`
		531	`};`
		532	`return;`
		533	`}`
		534
		535
		536	`#else`
		537
		538	`/*`
		539	`OUTPUT INITIAL DIAGNOSTICS FOR A DIAGNOSE_TAG`
		540	`*/`
		541
		542	`void stab_begin`
		543	`PROTO_N ( ( d, proc_no, e ) )`
		544	`PROTO_T ( diag_info * d X int proc_no X exp e )`
		545	`{`
		546	`exp x ;`
		547
		548	`if ( d->key == DIAG_INFO_SOURCE ) {`
		549	`sourcemark *s = &d->data.source.beg ;`
		550	`long f = find_file ( s->file->file.ints.chars ) ;`
		551	`stabd ( f, ( long ) s->line_no.nat_val.small_nat ,N_SLINE) ;`
		552	`return ;`
		553	`}`
		554
		555	`if ( d->key != DIAG_INFO_ID ) {`
		556	`/* not implemented */`
		557	`return ;`
		558	`}`
		559
		560	`x = d->data.id_scope.access ;`
		561	`/* MIPS */`
		562	`if ( isglob ( son ( x ) ) \|\| no ( son ( x ) ) == 1 ) return;`
		563
		564	`mark_scope ( e ) ;`
		565	`if ( props ( e ) & 0x80 ) {`
		566	`stab_scope_open ( currentfile ) ;`
		567	`stabd ( currentfile, ( long ) ( currentlno + 1 ), N_SLINE ) ;`
		568	`}`
		569
		570	`stab_local ( d->data.id_scope.nme.ints.chars, d->data.id_scope.typ,`
		571	`x, 0, currentfile ) ;`
		572
		573	`if ( last_param ( son ( x ) ) ) {`
		574	`stabd ( currentfile, ( long ) ( currentlno + 1 ),N_SLINE) ;`
		575	`}`
		576	`return ;`
		577	`}`
		578
		579
		580	`/*`
		581	`OUTPUT FINAL DIAGNOSTICS FOR A DIAGNOSE_TAG`
		582	`*/`
		583
		584	`void stab_end`
		585	`PROTO_N ( ( d, e ) )`
		586	`PROTO_T ( diag_info * d X exp e )`
		587	`{`
		588	`if ( d->key == DIAG_INFO_SOURCE ) {`
		589	`sourcemark *s = &d->data.source.end ;`
		590	`long f = find_file ( s->file->file.ints.chars ) ;`
		591	`long lno = s->line_no.nat_val.small_nat ;`
		592	`stabd (f,(long)lno,N_SLINE);`
		593	`return ;`
		594	`}`
		595	`if ( d->key == DIAG_INFO_ID && props ( e ) & 0x80 ) {`
		596	`stab_scope_close ( currentfile ) ;`
		597	`return ;`
		598	`}`
		599	`return ;`
		600	`}`
		601	`#endif`
		602
		603
		604
		605	`/*`
		606	`FIND THE STAB OF A SIMPLE SHAPE`
		607	`*/`
		608
		609	`#ifdef NEWDIAGS`
		610
		611	`static long out_sh_type`
		612	`PROTO_N ( ( s, nm ) )`
		613	`PROTO_T ( shape s X char* nm )`
		614	`{`
		615	`last_type_sz = shape_size ( s ) ;`
		616	`switch ( name ( s ) ) {`
		617	`case scharhd : return ( STAB_SCHAR ) ;`
		618	`case ucharhd : return ( STAB_UCHAR ) ;`
		619	`case swordhd : return ( STAB_SSHRT ) ;`
		620	`case uwordhd : return ( STAB_USHRT ) ;`
		621	`case slonghd : return ( strstr (nm, "long") ? STAB_SLONG : STAB_SINT ) ;`
		622	`case ulonghd : return ( strstr (nm, "long") ? STAB_ULONG : STAB_UINT ) ;`
		623	`case s64hd : return ( STAB_S64 ) ;`
		624	`case u64hd : return ( STAB_U64 ) ;`
		625	`case shrealhd : return ( STAB_FLOAT ) ;`
		626	`case realhd : return ( STAB_DBL ) ;`
		627	`case doublehd : return ( STAB_LDBL ) ;`
		628	`}`
		629	`return ( STAB_VOID ) ;`
		630	`}`
		631
		632	`static long find_basic_type`
		633	`PROTO_N ( ( s ) )`
		634	`PROTO_T ( char* s )`
		635	`{`
		636	`char* x;`
		637	`if (strstr (s, "char"))`
		638	`return ( strstr (s, "unsigned") ? STAB_UCHAR : STAB_SCHAR );`
		639	`if (strstr (s, "double"))`
		640	`return ( strstr (s, "long") ? STAB_LDBL : STAB_DBL );`
		641	`if (strstr (s, "float"))`
		642	`return ( STAB_FLOAT );`
		643	`if (strstr (s, "short"))`
		644	`return ( strstr (s, "unsigned") ? STAB_USHRT : STAB_SSHRT );`
		645	`if ( (x = strstr (s, "long"))) {`
		646	`if (strstr (x+1, "long"))`
		647	`return ( strstr (s, "unsigned") ? STAB_U64 : STAB_S64 );`
		648	`return ( strstr (s, "unsigned") ? STAB_ULONG : STAB_SLONG );`
		649	`}`
		650	`if (strstr (s, "int"))`
		651	`return ( strstr (s, "unsigned") ? STAB_UINT : STAB_SINT );`
		652	`if (strstr (s, "void_star"))`
		653	`return ( STAB_VS );`
		654	`return ( STAB_VOID ) ;`
		655	`}`
		656
		657	`#else`
		658
		659	`static long out_sh_type`
		660	`PROTO_N ( ( s ) )`
		661	`PROTO_T ( shape s )`
		662	`{`
		663	`last_type_sz = shape_size ( s ) ;`
		664	`switch ( name ( s ) ) {`
		665	`case scharhd : return ( STAB_SCHAR ) ;`
		666	`case ucharhd : return ( STAB_UCHAR ) ;`
		667	`case swordhd : return ( STAB_SSHRT ) ;`
		668	`case uwordhd : return ( STAB_USHRT ) ;`
		669	`case slonghd : return ( STAB_SINT ) ;`
		670	`case ulonghd : return ( STAB_UINT ) ;`
		671	`case s64hd : return ( STAB_S64 ) ;`
		672	`case u64hd : return ( STAB_U64 ) ;`
		673	`case shrealhd : return ( STAB_FLOAT ) ;`
		674	`case realhd : return ( STAB_DBL ) ;`
		675	`case doublehd : return ( STAB_LDBL ) ;`
		676	`}`
		677	`return ( STAB_VOID ) ;`
		678	`}`
		679
		680	`#endif`
		681
		682
		683	`/*`
		684	`OUTPUT DIAGNOSTICS DIRECTIVE FOR A FILE`
		685	`*/`
		686
		687	`#ifdef NEWDIAGS`
		688
		689	`static void stab_file`
		690	`PROTO_N ( ( f ) )`
		691	`PROTO_T ( dg_filename f )`
		692	`{`
		693	`long i = next_d_lab () ;`
		694	`int stb;`
		695
		696	`if ( f == currentfile \|\| !f ) {`
		697	`return ;`
		698	`}`
		699
		700	`stb = (f == prim_file ? 0x64 : 0x84);`
		701
		702	`if (f->file_name[0] != '/' && f->file_path[0])`
		703	`fprintf ( dg_file, "\t.stabs\t\"%s/\",0x%x,0,0,.LL.%ld\n", f->file_path, stb, i );`
		704
		705	`fprintf ( dg_file, "\t.stabs\t\"%s\",0x%x,0,0,.LL.%ld\n", f->file_name, stb, i );`
		706
		707	`fprintf ( dg_file, ".LL.%ld:\n", i ) ;`
		708	`currentfile = f ;`
		709	`return ;`
		710	`}`
		711
		712	`#else`
		713
		714	`void stab_file`
		715	`PROTO_N ( ( findex, internal ) )`
		716	`PROTO_T ( long findex X bool internal )`
		717	`{`
		718	`static long i = 0 ;`
		719
		720	`if ( findex == currentfile \|\| findex < 0 \|\| findex >= szfds ) {`
		721	`return ;`
		722	`}`
		723
		724	`if ( !internal ) {`
		725	`/* source file */`
		726	`i = next_d_lab () ;`
		727	`fprintf ( dg_file, "\t.stabs\t\"%s\",0x64,0,0,.LL.%ld\n",`
		728	`fds [ findex ]->file.ints.chars, i ) ;`
		729	`fprintf ( dg_file, ".LL.%ld:\n", i ) ;`
		730	`}`
		731	`else {`
		732	`/* included file */`
		733	`fprintf ( dg_file, "\t.stabs\t\"%s\",0x84,0,0,.LL.%ld\n",`
		734	`fds [ findex ]->file.ints.chars, i ) ;`
		735	`}`
		736	`currentfile = findex ;`
		737	`return ;`
		738	`}`
		739
		740	`#endif`
		741
		742
		743	`/*`
		744	`LIST OF DIAGNOSTIC SCOPES AND LOCAL VARIABLES`
		745	`*/`
		746
		747	`#define DEL_SIZE 50`
		748
		749	`struct delay_stab {`
		750	`int del_t;`
		751	`union {`
		752	`struct {`
		753	`char * nm;`
		754	`#ifdef NEWDIAGS`
		755	`dg_type dt;`
		756	`#else`
		757	`diag_type dt;`
		758	`#endif`
		759	`int offset;`
		760	`} l;`
		761	`struct {`
		762	`int br;`
		763	`int lev;`
		764	`int lab;`
		765	`} b;`
		766	`} u;`
		767	`};`
		768
		769	`enum del_types {D_PARAM, D_LOCAL, D_BRACKET};`
		770
		771	`struct del_stab_array {`
		772	`struct del_stab_array *more;`
		773	`struct delay_stab a [DEL_SIZE];`
		774	`};`
		775
		776	`static struct del_stab_array *del_stab_start = NULL;`
		777	`static struct del_stab_array *last_del_array = NULL;`
		778	`static struct del_stab_array *c_del_array = NULL;`
		779	`static int c_del_index = DEL_SIZE;`
		780
		781	`static struct delay_stab * next_del_stab`
		782	`PROTO_Z ()`
		783	`{`
		784	`if (c_del_index == DEL_SIZE) {`
		785	`if (c_del_array != last_del_array)`
		786	`c_del_array = c_del_array -> more;`
		787	`else {`
		788	`struct del_stab_array * s =`
		789	`(struct del_stab_array *) (xmalloc (sizeof(struct del_stab_array)));`
		790	`s -> more = NULL;`
		791	`if (del_stab_start == NULL)`
		792	`del_stab_start = s;`
		793	`else`
		794	`last_del_array -> more = s;`
		795	`c_del_array = last_del_array = s;`
		796	`}`
		797	`c_del_index = 0;`
		798	`}`
		799	`return ((c_del_array -> a) + (c_del_index ++));`
		800	`}`
		801
		802	`static long open_label = 0 ;`
		803	`static long bracket_level = 1 ;`
		804
		805
		806	`/*`
		807	`START OF A DIAGNOSTICS SCOPE`
		808	`*/`
		809
		810	`#ifdef NEWDIAGS`
		811
		812	`static void stab_scope_open`
		813	`PROTO_N ( ( f ) )`
		814	`PROTO_T ( dg_filename f )`
		815	`{`
		816	`long i ;`
		817	`stab_file ( f ) ;`
		818	`if ( open_label != 0 )`
		819	`{`
		820	`struct delay_stab * t = next_del_stab();`
		821	`t->del_t = D_BRACKET;`
		822	`t->u.b.br = N_LBRAC;`
		823	`t->u.b.lev = bracket_level;`
		824	`t->u.b.lab = open_label;`
		825	`}`
		826	`i = next_d_lab () ;`
		827	`fprintf ( dg_file, ".LL.%ld:\n", i ) ;`
		828	`open_label = i ;`
		829	`bracket_level++ ;`
		830	`return ;`
		831	`}`
		832
		833	`#else`
		834
		835	`static void stab_scope_open`
		836	`PROTO_N ( ( findex ) )`
		837	`PROTO_T ( long findex )`
		838	`{`
		839	`long i ;`
		840	`stab_file ( findex, 1 ) ;`
		841	`if ( open_label != 0 )`
		842	`{`
		843	`struct delay_stab * t = next_del_stab();`
		844	`t->del_t = D_BRACKET;`
		845	`t->u.b.br = N_LBRAC;`
		846	`t->u.b.lev = bracket_level;`
		847	`t->u.b.lab = open_label;`
		848	`}`
		849	`i = next_d_lab () ;`
		850	`fprintf ( dg_file, ".LL.%ld:\n", i ) ;`
		851	`open_label = i ;`
		852	`bracket_level++ ;`
		853	`return ;`
		854	`}`
		855
		856	`#endif`
		857
		858
		859	`/*`
		860	`END OF A DIAGNOSTICS SCOPE`
		861	`*/`
		862
		863	`#ifdef NEWDIAGS`
		864
		865	`static void stab_scope_close`
		866	`PROTO_Z ()`
		867	`{`
		868	`long i ;`
		869	`struct delay_stab * x;`
		870	`if ( open_label != 0 ) {`
		871	`struct delay_stab * t = next_del_stab();`
		872	`t->del_t = D_BRACKET;`
		873	`t->u.b.br = N_LBRAC;`
		874	`t->u.b.lev = bracket_level;`
		875	`t->u.b.lab = open_label;`
		876	`open_label = 0 ;`
		877	`}`
		878	`i = next_d_lab () ;`
		879	`x = next_del_stab();`
		880	`x->del_t = D_BRACKET;`
		881	`x->u.b.br = N_RBRAC;`
		882	`x->u.b.lev = bracket_level;`
		883	`x->u.b.lab = i;`
		884	`fprintf ( dg_file, ".LL.%ld:\n", i ) ;`
		885	`bracket_level-- ;`
		886	`return ;`
		887	`}`
		888
		889	`#else`
		890
		891	`static void stab_scope_close`
		892	`PROTO_N ( ( findex ) )`
		893	`PROTO_T ( long findex )`
		894	`{`
		895	`long i ;`
		896	`struct delay_stab * x;`
		897	`if ( open_label != 0 ) {`
		898	`struct delay_stab * t = next_del_stab();`
		899	`t->del_t = D_BRACKET;`
		900	`t->u.b.br = N_LBRAC;`
		901	`t->u.b.lev = bracket_level;`
		902	`t->u.b.lab = open_label;`
		903	`open_label = 0 ;`
		904	`}`
		905	`i = next_d_lab () ;`
		906	`x = next_del_stab();`
		907	`x->del_t = D_BRACKET;`
		908	`x->u.b.br = N_RBRAC;`
		909	`x->u.b.lev = bracket_level;`
		910	`x->u.b.lab = i;`
		911	`fprintf ( dg_file, ".LL.%ld:\n", i ) ;`
		912	`bracket_level-- ;`
		913	`return ;`
		914	`}`
		915
		916	`#endif`
		917
		918
		919	`/*`
		920	`DEPTH COUNT FOR STAB TYPES`
		921	`*/`
		922
		923	`static int max_depth = 64 ;`
		924	`static int depth_now = 0 ;`
		925
		926
		927	`/*`
		928	`OUTPUT A DIAGNOSTICS TYPE`
		929	`*/`
		930
		931	`#define OUT_DT_SHAPE( dt ) out_dt_shape ( ( depth_now = 0, dt ) )`
		932
		933	`#ifdef NEWDIAGS`
		934
		935	`static long type_size`
		936	`PROTO_N ( (dt) )`
		937	`PROTO_T ( dg_type dt )`
		938	`{`
		939	`if (!dt)`
		940	`return 0;`
		941	`if ( dt->outref.k == LAB_D \|\| dt->outref.k < 0 )`
		942	`return get_stab_size ( dt->outref.u.l ) ;`
		943	`switch ( dt->key ) {`
		944	`case DGT_TAGGED: {`
		945	`dg_tag tag = dt->data.t_tag;`
		946	`if (tag->key == DGK_NONE) {`
		947	`return 0;`
		948	`}`
		949	`if (tag->key == DGK_TYPE) {`
		950	`dg_type ref_t = tag->p.typ;`
		951	`if (ref_t == dt)`
		952	`return type_sizes [ find_basic_type (ref_t->outref.u.s) ];`
		953	`return type_size (ref_t);`
		954	`}`
		955	`if (tag->key == DGK_NAME) {`
		956	`dg_name ref_n = tag->p.nam;`
		957	`if (ref_n->key == DGN_TYPE /* && ref_n->idnam.id_key == DG_ID_NONE */) {`
		958	`dg_type ref_t = tag->p.nam->data.n_typ.raw;`
		959	`return type_size (ref_t);`
		960	`}`
		961	`}`
		962	`return 0;`
		963	`}`
		964	`case DGT_BASIC: {`
		965	`return shape_size (dt->data.t_bas.b_sh);`
		966	`}`
		967	`case DGT_QUAL: {`
		968	`if (dt->data.t_qual.q_key == DG_PTR_T)`
		969	`return 32;`
		970	`{`
		971	`dg_type pdt = dt->data.t_qual.typ ;`
		972	`return type_size ( pdt ) ;`
		973	`}`
		974	`}`
		975	`case DGT_ARRAY: {`
		976	`if (dt->data.t_arr.dims.len == 1) {`
		977	`dg_dim x;`
		978	`x = dt->data.t_arr.dims.array[0];`
		979	`if (x.d_key == DG_DIM_BOUNDS && !x.low_ref && !x.hi_ref && !x.hi_cnt) {`
		980	`long lwb = no (son(x.lower.x));`
		981	`long upb = no (son(x.upper.x));`
		982	`long stride = no (son(dt->data.t_arr.stride));`
		983	`return ( stride * ( upb - lwb + 1 ) );`
		984
		985	`}`
		986	`}`
		987	`return 0;`
		988	`}`
		989	`case DGT_ENUM: {`
		990	`return shape_size (dt->data.t_enum.sha);`
		991	`}`
		992	`case DGT_STRUCT: {`
		993	`return shape_size (dt->data.t_struct.sha);`
		994	`}`
		995	`case DGT_BITF : {`
		996	`return dt->data.t_bitf.bv.bits;`
		997	`}`
		998	`case DGT_PROC: {`
		999	`return 32;`
		1000	`}`
		1001	`default :`
		1002	`return 0;`
		1003	`}`
		1004	`}`
		1005
		1006	`static void out_dt_shape`
		1007	`PROTO_N ( ( dt ) )`
		1008	`PROTO_T ( dg_type dt )`
		1009	`{`
		1010	`if (!dt) {`
		1011	`fprintf ( dg_file, "%d", STAB_VOID ) ;`
		1012	`last_type_sz = 0 ;`
		1013	`return ;`
		1014	`}`
		1015
		1016	`if ( dt->outref.k == LAB_D \|\| ( dt->outref.k < 0 && depth_now != 0 ) ) {`
		1017	`fprintf ( dg_file, "%ld", dt->outref.u.l ) ;`
		1018	`last_type_sz = get_stab_size ( dt->outref.u.l ) ;`
		1019	`return ;`
		1020	`}`
		1021
		1022	`depth_now++ ;`
		1023
		1024	`switch ( dt->key ) {`
		1025
		1026	`case DGT_TAGGED: {`
		1027	`dg_tag tag = dt->data.t_tag;`
		1028	`if (tag->done) {`
		1029	`dt->outref = tag->outref;`
		1030	`out_dt_shape (dt);`
		1031	`break;`
		1032	`}`
		1033	`if (tag->key == DGK_NONE) {`
		1034	`failer ("external type");`
		1035	`tag->done = 1;`
		1036	`tag->outref.k = LAB_D;`
		1037	`tag->outref.u.l = 0;`
		1038	`out_dt_shape (dt);`
		1039	`break;`
		1040	`}`
		1041	`if (tag->key == DGK_TYPE) {`
		1042	`dg_type ref_t = tag->p.typ;`
		1043	`if (ref_t == dt) {`
		1044	`if (ref_t->outref.k != LAB_STR)`
		1045	`failer ("uninitialised?");`
		1046	`ref_t->outref.k = LAB_D;`
		1047	`ref_t->outref.u.l = find_basic_type (ref_t->outref.u.s);`
		1048	`}`
		1049	`out_dt_shape (ref_t);`
		1050	`dt->outref = tag->outref = ref_t->outref;`
		1051	`tag->done = 1;`
		1052	`break;`
		1053	`}`
		1054	`if (tag->key == DGK_NAME) {`
		1055	`dg_name ref_n = tag->p.nam;`
		1056	`if (ref_n->key == DGN_TYPE /* && ref_n->idnam.id_key == DG_ID_NONE */) {`
		1057	`dg_type ref_t = tag->p.nam->data.n_typ.raw;`
		1058	`out_dt_shape (ref_t);`
		1059	`dt->outref = tag->outref = ref_t->outref;`
		1060	`tag->done = 1;`
		1061	`break;`
		1062	`}`
		1063	`}`
		1064	`failer ("unfinished convolution");`
		1065	`tag->done = 1;`
		1066	`tag->outref.k = LAB_D;`
		1067	`tag->outref.u.l = 0;`
		1068	`out_dt_shape (dt);`
		1069	`break;`
		1070	`}`
		1071
		1072	`case DGT_BASIC: {`
		1073	`dt->outref.u.l = out_sh_type (dt->data.t_bas.b_sh, dt->data.t_bas.tnam);`
		1074	`dt->outref.k = LAB_D;`
		1075	`out_dt_shape (dt);`
		1076	`break;`
		1077	`}`
		1078
		1079	`case DGT_QUAL: {`
		1080	`if (dt->data.t_qual.q_key == DG_PTR_T) {`
		1081	`long non ;`
		1082	`dg_type pdt = dt->data.t_qual.typ ;`
		1083	`if ( pdt->key == DGT_BASIC ) {`
		1084	`long pn = out_sh_type (pdt->data.t_bas.b_sh, pdt->data.t_bas.tnam);`
		1085	`non = stab_ptrs [ pn ] ;`
		1086	`if ( non == 0 ) {`
		1087	`non = (dt->outref.k < 0 ? dt->outref.u.l : next_typen ()) ;`
		1088	`stab_ptrs [ pn ] = non ;`
		1089	`fprintf ( dg_file, "%ld=*%ld", non, pn ) ;`
		1090	`}`
		1091	`else {`
		1092	`fprintf ( dg_file, "%ld", non ) ;`
		1093	`}`
		1094	`}`
		1095	`else {`
		1096	`non = (dt->outref.k < 0 ? dt->outref.u.l : next_typen ()) ;`
		1097	`fprintf ( dg_file, "%ld=*", non ) ;`
		1098	`out_dt_shape ( pdt ) ;`
		1099	`}`
		1100	`dt->outref.u.l = non ;`
		1101	`dt->outref.k = LAB_D;`
		1102	`last_type_sz = 32 ;`
		1103	`set_stab_size ( non ) ;`
		1104	`}`
		1105	`else {`
		1106	`dg_type pdt = dt->data.t_qual.typ ;`
		1107	`out_dt_shape ( pdt ) ;`
		1108	`dt->outref = pdt->outref;`
		1109	`}`
		1110	`break;`
		1111	`}`
		1112
		1113	`case DGT_ARRAY: {`
		1114	`long non;`
		1115	`if (dt->outref.k >= 0)`
		1116	`dt->outref.u.l = next_typen () ;`
		1117	`dt->outref.k = LAB_D;`
		1118	`non = dt->outref.u.l;`
		1119	`if (dt->data.t_arr.dims.len == 1) {`
		1120	`dg_dim x;`
		1121	`x = dt->data.t_arr.dims.array[0];`
		1122	`if (x.d_key == DG_DIM_BOUNDS && !x.low_ref && !x.hi_ref && !x.hi_cnt) {`
		1123	`long lwb = no (son(x.lower.x));`
		1124	`long upb = no (son(x.upper.x));`
		1125	`long stride = no (son(dt->data.t_arr.stride));`
		1126	`dg_type index_type = x.d_typ;`
		1127	`dg_type element_type = dt->data.t_arr.elem_type;`
		1128	`fprintf ( dg_file, "%ld=", non ) ;`
		1129	`fprintf ( dg_file, "ar" ) ;`
		1130	`out_dt_shape ( index_type ) ;`
		1131	`fprintf ( dg_file, ";%ld;%ld;", lwb, upb ) ;`
		1132	`out_dt_shape ( element_type ) ;`
		1133	`last_type_sz = stride * ( upb - lwb + 1 ) ;`
		1134	`set_stab_size ( non ) ;`
		1135	`break ;`
		1136	`}`
		1137	`if (x.d_key == DG_DIM_NONE) {`
		1138	`dg_type index_type = x.d_typ;`
		1139	`dg_type element_type = dt->data.t_arr.elem_type;`
		1140	`fprintf ( dg_file, "%ld=", non ) ;`
		1141	`fprintf ( dg_file, "ar" ) ;`
		1142	`out_dt_shape ( index_type ) ;`
		1143	`fprintf ( dg_file, ";0;0;" ) ;`
		1144	`out_dt_shape ( element_type ) ;`
		1145	`last_type_sz = 0 ;`
		1146	`set_stab_size ( non ) ;`
		1147	`break ;`
		1148	`}`
		1149	`}`
		1150	`failer ("complex array");`
		1151	`break;`
		1152	`}`
		1153
		1154	`case DGT_ENUM: {`
		1155	`int i ;`
		1156	`dg_enum * el = dt->data.t_enum.values.array;`
		1157	`if (dt->outref.k >= 0)`
		1158	`dt->outref.u.l = next_typen () ;`
		1159	`dt->outref.k = LAB_D;`
		1160	`fprintf ( dg_file, "%ld=e", dt->outref.u.l ) ;`
		1161	`for (i = 0; i < dt->data.t_enum.values.len; i++) {`
		1162	`fprintf ( dg_file, "%s:%d,", el[i].enam, no (son(el[i].value)) );`
		1163	`}`
		1164	`fprintf ( dg_file, ";" ) ;`
		1165	`last_type_sz = shape_size (dt->data.t_enum.sha);`
		1166	`set_stab_size ( dt->outref.u.l ) ;`
		1167	`break ;`
		1168	`}`
		1169
		1170	`case DGT_STRUCT: {`
		1171	`int i ;`
		1172	`char su = (dt->data.t_struct.is_union ? 'u' : 's');`
		1173	`shape s = dt->data.t_struct.sha;`
		1174	`dg_classmem * el = dt->data.t_struct.u.fields.array;`
		1175	`if (dt->outref.k >= 0)`
		1176	`dt->outref.u.l = next_typen () ;`
		1177	`dt->outref.k = LAB_D;`
		1178	`fprintf ( dg_file, "%ld=%c%d", dt->outref.u.l, su, shape_size ( s ) / 8 ) ;`
		1179	`for (i = 0; i < dt->data.t_struct.u.fields.len; i++) {`
		1180	`long offset = no ( son(el[i].d.cm_f.f_offset) );`
		1181	`if(depth_now >= max_depth){`
		1182	`depth_now = 0;`
		1183	`fprintf (dg_file, "\\\\\",0x80,0,%d,%d\n",0,0 ) ;`
		1184	`fprintf(dg_file,"\t.stabs\t\"");`
		1185	`}`
		1186	`depth_now++ ;`
		1187	`fprintf ( dg_file, "%s:", el[i].d.cm_f.fnam ) ;`
		1188	`out_dt_shape ( el[i].d.cm_f.f_typ ) ;`
		1189	`fprintf ( dg_file, ",%ld,%ld;", offset, type_size ( el[i].d.cm_f.f_typ ) ) ;`
		1190	`}`
		1191	`fprintf ( dg_file, ";" ) ;`
		1192	`last_type_sz = shape_size ( s ) ;`
		1193	`set_stab_size ( dt->outref.u.l ) ;`
		1194	`break ;`
		1195	`}`
		1196
		1197	`case DGT_BITF : {`
		1198	`bitfield_variety bv;`
		1199	`bv = dt->data.t_bitf.bv;`
		1200	`fprintf ( dg_file, "%d", (bv.has_sign ? STAB_SINT : STAB_UINT) ) ;`
		1201	`last_type_sz = bv.bits ;`
		1202	`break ;`
		1203	`}`
		1204
		1205	`case DGT_PROC: {`
		1206	`dg_type result_type = dt->data.t_proc.res_type ;`
		1207	`long non1 = next_typen () ;`
		1208	`long non2 = next_typen () ;`
		1209	`dt->outref.u.l = non1;`
		1210	`dt->outref.k = LAB_D;`
		1211	`fprintf ( dg_file, "%ld=*%ld=f", non1, non2 ) ;`
		1212	`out_dt_shape ( result_type ) ;`
		1213	`last_type_sz = 32 ;`
		1214	`set_stab_size ( non1 ) ;`
		1215	`set_stab_size ( non2 ) ;`
		1216	`break ;`
		1217	`}`
		1218
		1219	`default : {`
		1220	`fprintf ( dg_file, "%d", STAB_VOID ) ;`
		1221	`dt->outref.u.l = STAB_VOID;`
		1222	`dt->outref.k = LAB_D;`
		1223	`last_type_sz = 0 ;`
		1224	`break ;`
		1225	`}`
		1226	`}`
		1227	`#if 0`
		1228	`if (dt->mor && dt->mor->this_tag)`
		1229	`dt->mor->this_tag->outref = dt->outref;`
		1230	`#endif`
		1231	`return ;`
		1232	`}`
		1233
		1234
		1235	`#else`
		1236
		1237	`static void out_dt_shape`
		1238	`PROTO_N ( ( dt ) )`
		1239	`PROTO_T ( diag_type dt )`
		1240	`{`
		1241	`if ( dt->been_outed ) {`
		1242	`fprintf ( dg_file, "%d",(int) dt->been_outed ) ;`
		1243	`last_type_sz = get_stab_size ( dt->been_outed ) ;`
		1244	`return ;`
		1245	`}`
		1246
		1247	`depth_now++ ;`
		1248
		1249	`switch ( dt->key ) {`
		1250
		1251	`case DIAG_TYPE_PTR : {`
		1252	`long non ;`
		1253	`diag_type pdt = dt->data.ptr.object ;`
		1254	`if ( pdt->key == DIAG_TYPE_VARIETY ) {`
		1255	`long pn = out_sh_type ( f_integer ( pdt->data.var ) ) ;`
		1256	`non = stab_ptrs [ pn ] ;`
		1257	`if ( non == 0 ) {`
		1258	`non = next_typen () ;`
		1259	`stab_ptrs [ pn ] = non ;`
		1260	`fprintf ( dg_file, "%ld=*%ld", non, pn ) ;`
		1261	`}`
		1262	`else {`
		1263	`fprintf ( dg_file, "%ld", non ) ;`
		1264	`}`
		1265	`}`
		1266	`else {`
		1267	`non = next_typen () ;`
		1268	`fprintf ( dg_file, "%ld=*", non ) ;`
		1269	`out_dt_shape ( dt->data.ptr.object ) ;`
		1270	`}`
		1271	`dt->been_outed = non ;`
		1272	`last_type_sz = 32 ;`
		1273	`set_stab_size ( non ) ;`
		1274	`break ;`
		1275	`}`
		1276	`case DIAG_TYPE_ARRAY : {`
		1277	`long lwb = no ( dt->data.array.lower_b ) ;`
		1278	`long upb = no ( dt->data.array.upper_b ) ;`
		1279	`diag_type index_type = dt->data.array.index_type ;`
		1280	`diag_type element_type = dt->data.array.element_type ;`
		1281	`long non = next_typen () ;`
		1282	`dt->been_outed = non ;`
		1283	`fprintf ( dg_file, "%ld=", non ) ;`
		1284	`fprintf ( dg_file, "ar" ) ;`
		1285	`out_dt_shape ( index_type ) ;`
		1286	`fprintf ( dg_file, ";%ld;%ld;", lwb, upb ) ;`
		1287	`out_dt_shape ( element_type ) ;`
		1288	`last_type_sz *= ( upb - lwb + 1 ) ;`
		1289	`set_stab_size ( non ) ;`
		1290	`break ;`
		1291	`}`
		1292
		1293	`case DIAG_TYPE_STRUCT :`
		1294	`case DIAG_TYPE_UNION : {`
		1295	`int i ;`
		1296	`char su ;`
		1297	`shape s ;`
		1298	`diag_field_list fields ;`
		1299	`long non = next_typen () ;`
		1300	`dt->been_outed = non ;`
		1301
		1302	`if ( dt->key == DIAG_TYPE_STRUCT ) {`
		1303	`fields = dt->data.t_struct.fields ;`
		1304	`s = dt->data.t_struct.tdf_shape ;`
		1305	`su = 's';`
		1306	`}`
		1307	`else {`
		1308	`fields = dt->data.t_union.fields ;`
		1309	`s = dt->data.t_union.tdf_shape;`
		1310	`su = 'u' ;`
		1311	`}`
		1312	`fprintf ( dg_file, "%ld=%c%d", non, su, shape_size ( s ) / 8 ) ;`
		1313
		1314	`for ( i = fields->lastused - 1 ; i >= 0 ; i-- ) {`
		1315	`diag_field sf = ( fields->array ) [i] ;`
		1316	`long offset = no ( sf->where );`
		1317
		1318	`/* if ( depth_now >= max_depth ) return ;*/`
		1319	`if(depth_now >= max_depth){`
		1320	`depth_now = 0;`
		1321	`fprintf (dg_file, "\\\\\",0x80,0,%d,%d\n",0,0 ) ;`
		1322	`fprintf(dg_file,"\t.stabs\t\"");`
		1323	`}`
		1324	`depth_now++ ;`
		1325	`fprintf ( dg_file, "%s:", sf->field_name.ints.chars ) ;`
		1326	`out_dt_shape ( sf->field_type ) ;`
		1327	`fprintf ( dg_file, ",%ld,%ld;", offset, last_type_sz ) ;`
		1328	`}`
		1329	`fprintf ( dg_file, ";" ) ;`
		1330	`last_type_sz = shape_size ( s ) ;`
		1331	`set_stab_size ( non ) ;`
		1332	`break ;`
		1333	`}`
		1334
		1335	`case DIAG_TYPE_VARIETY : {`
		1336	`dt->been_outed = out_sh_type ( f_integer ( dt->data.var ) ) ;`
		1337	`fprintf ( dg_file, "%ld", dt->been_outed ) ;`
		1338	`break ;`
		1339	`}`
		1340
		1341	`case DIAG_TYPE_PROC : {`
		1342	`diag_type result_type = dt->data.proc.result_type ;`
		1343	`long non1 = next_typen () ;`
		1344	`long non2 = next_typen () ;`
		1345	`dt->been_outed = non1 ;`
		1346	`fprintf ( dg_file, "%ld=*%ld=f", non1, non2 ) ;`
		1347	`out_dt_shape ( result_type ) ;`
		1348	`last_type_sz = 32 ;`
		1349	`set_stab_size ( non1 ) ;`
		1350	`set_stab_size ( non2 ) ;`
		1351	`break ;`
		1352	`}`
		1353
		1354	`case DIAG_TYPE_LOC : {`
		1355	`/* +++ use qualifier which gives "const"/"volatile" */`
		1356	`out_dt_shape ( dt->data.loc.object ) ;`
		1357	`break ;`
		1358	`}`
		1359
		1360	`case DIAG_TYPE_FLOAT : {`
		1361	`dt->been_outed = out_sh_type ( f_floating ( dt->data.f_var ) ) ;`
		1362	`fprintf ( dg_file, "%ld", dt->been_outed ) ;`
		1363	`break ;`
		1364	`}`
		1365
		1366	`case DIAG_TYPE_NULL : {`
		1367	`fprintf ( dg_file, "%d", STAB_VOID ) ;`
		1368	`last_type_sz = 0 ;`
		1369	`break ;`
		1370	`}`
		1371
		1372	`case DIAG_TYPE_BITFIELD : {`
		1373	`long sz = dt->data.bitfield.no_of_bits.nat_val.small_nat ;`
		1374	`fprintf ( dg_file, "%d", STAB_SINT ) ;`
		1375	`last_type_sz = sz ;`
		1376	`break ;`
		1377	`}`
		1378
		1379	`case DIAG_TYPE_ENUM : {`
		1380	`int i ;`
		1381	`enum_values_list enumvals = dt->data.t_enum.values;`
		1382	`long non = next_typen () ;`
		1383	`dt->been_outed = non ;`
		1384	`fprintf ( dg_file, "%ld=e", non ) ;`
		1385	`for ( i = enumvals->lastused - 1 ; i >= 0 ; i-- ) {`
		1386	`enum_values ef = ( enumvals->array ) [i] ;`
		1387	`fprintf ( dg_file, "%s:%d,", ef->nme.ints.chars, no ( ef->val ) );`
		1388	`}`
		1389	`fprintf ( dg_file, ";" ) ;`
		1390	`last_type_sz = 32 ;`
		1391	`set_stab_size ( non ) ;`
		1392	`break ;`
		1393	`}`
		1394
		1395	`default : {`
		1396	`fprintf ( dg_file, "%d", STAB_VOID ) ;`
		1397	`last_type_sz = 0 ;`
		1398	`break ;`
		1399	`}`
		1400	`}`
		1401	`return ;`
		1402	`}`
		1403
		1404	`#endif`
		1405
		1406
		1407	`/*`
		1408	`OUTPUT DIAGNOSTICS FOR A GLOBAL VARIABLE`
		1409	`*/`
		1410
		1411	`#ifdef NEWDIAGS`
		1412
		1413	`void stab_global`
		1414	`PROTO_N ( ( di, global, id, ext ) )`
		1415	`PROTO_T ( dg_name di X exp global X char * id X int ext )`
		1416	`{`
		1417	`char* nm;`
		1418	`dg_type dt;`
		1419	`if (!di \|\| di->key != DGN_OBJECT)`
		1420	`return;`
		1421	`nm = idname_chars (di->idnam);`
		1422	`dt = di->data.n_obj.typ;`
		1423
		1424	`if (di->whence.line)`
		1425	`stabd ( di->whence.file, di->whence.line, -N_DSLINE ) ;`
		1426	`fprintf ( dg_file, "\t.stabs\t\"%s:%c", nm, ( ext ? 'G' : 'S' ) ) ;`
		1427	`OUT_DT_SHAPE ( dt ) ;`
		1428	`fprintf ( dg_file, "\",%#x,0,%ld,%s\n", ( ext ? 0x24 : ((no(global)!=0)?0x26:0x28) ),`
		1429	`/* solaris puts line no,0 rather than`
		1430	`0, varname, so suppress the stabd`
		1431	`above, and do here. */`
		1432	`di->whence.line,`
		1433	`id`
		1434	`) ;`
		1435	`return ;`
		1436	`}`
		1437
		1438	`#else`
		1439
		1440	`void stab_global`
		1441	`PROTO_N ( ( dd, global, id, ext ) )`
		1442	`PROTO_T ( diag_descriptor * dd X exp global X char * id X bool ext )`
		1443	`{`
		1444	`if ( dd == NULL ) return ;`
		1445
		1446	`stabd ( find_file ( dd->data.id.whence.file->file.ints.chars ),`
		1447	`( long ) dd->data.id.whence.line_no.nat_val.small_nat`
		1448	`, -N_DSLINE ) ;`
		1449
		1450	`fprintf ( dg_file, "\t.stabs\t\"%s:%c", dd->data.id.nme.ints.chars,`
		1451	`( ext ? 'G' : 'S' ) ) ;`
		1452	`OUT_DT_SHAPE ( dd->data.id.new_type ) ;`
		1453	`fprintf ( dg_file, "\",%#x,0,%ld,%s\n", ( ext ? 0x24 : ((no(global)!=0)?0x26:0x28) ),`
		1454	`/* solaris puts line no,0 rather than`
		1455	`0, varname, so suppress the stabd`
		1456	`above, and do here. */`
		1457	`dd->data.id.whence.line_no.nat_val.small_nat,`
		1458	`id`
		1459	`) ;`
		1460	`return ;`
		1461	`}`
		1462
		1463	`#endif`
		1464
		1465
		1466
		1467	`/*`
		1468	`OUTPUT DIAGNOSTICS FOR A PROCEDURE`
		1469	`*/`
		1470
		1471	`#ifdef NEWDIAGS`
		1472
		1473	`void stab_proc`
		1474	`PROTO_N ( ( di, proc, id, ext ) )`
		1475	`PROTO_T ( dg_name di X exp proc X char * id X int ext )`
		1476	`{`
		1477	`char* nm;`
		1478	`dg_type dt;`
		1479	`if (!di \|\| di->key != DGN_PROC)`
		1480	`return;`
		1481	`nm = idname_chars (di->idnam);`
		1482	`dt = di->data.n_proc.typ;`
		1483	`if (dt->key == DGT_PROC) /* it should be */`
		1484	`dt = dt->data.t_proc.res_type;`
		1485
		1486	`last_proc_lab = id;`
		1487	`if (di->whence.line)`
		1488	`stabd ( di->whence.file, di->whence.line, 0 ) ;`
		1489	`fprintf ( dg_file, "\t.stabs\t\"%s:%c", nm, ( ext ? 'F' : 'f' ) ) ;`
		1490	`OUT_DT_SHAPE ( dt ) ;`
		1491	`fprintf ( dg_file, "\",0x24,0,%ld,%s\n", di->whence.line, id ) ;`
		1492	`return ;`
		1493	`}`
		1494
		1495
		1496	`#else`
		1497
		1498	`void stab_proc`
		1499	`PROTO_N ( ( dd, proc, id, ext ) )`
		1500	`PROTO_T ( diag_descriptor * dd X exp proc X char * id X bool ext )`
		1501	`{`
		1502
		1503	`last_proc_lab = id; /* id is passed from translate_capsule,`
		1504	`so stays in scope while needed */`
		1505	`if ( dd == NULL ) return ;`
		1506
		1507	`stabd ( find_file ( dd->data.id.whence.file->file.ints.chars ),`
		1508	`( long ) dd->data.id.whence.line_no.nat_val.small_nat`
		1509	`,0) ;`
		1510
		1511	`fprintf ( dg_file, "\t.stabs\t\"%s:%c",`
		1512	`dd->data.id.nme.ints.chars, ( ext ? 'F' : 'f' ) ) ;`
		1513	`OUT_DT_SHAPE ( dd->data.id.new_type->data.proc.result_type ) ;`
		1514	`fprintf ( dg_file, "\",0x24,0,%ld,%s\n",`
		1515	`dd->data.id.whence.line_no.nat_val.small_nat, id ) ;`
		1516	`return ;`
		1517	`}`
		1518
		1519	`#endif`
		1520
		1521
		1522	`void stab_proc_end`
		1523	`PROTO_Z ()`
		1524	`{`
		1525	`if (del_stab_start != NULL) {`
		1526	`struct del_stab_array *this_a = del_stab_start;`
		1527	`int this_i = 0;`
		1528	`while (this_a != c_del_array \|\| this_i != c_del_index) {`
		1529	`struct delay_stab * t;`
		1530	`if (this_i == DEL_SIZE) {`
		1531	`this_a = this_a -> more;`
		1532	`this_i = 0;`
		1533	`}`
		1534	`t = (this_a -> a) + (this_i ++);`
		1535	`switch (t -> del_t) {`
		1536	`case D_PARAM: {`
		1537	`long disp = t->u.l.offset;`
		1538	`fprintf ( dg_file, "\t.stabs\t\"%s:p", t->u.l.nm);`
		1539	`OUT_DT_SHAPE ( t->u.l.dt ) ;`
		1540	`fprintf ( dg_file, "\",0xa0,0,%d,%ld\n", 0, disp);`
		1541	`if (disp <= 88) { /* register useage comment */`
		1542	`fprintf ( dg_file, "\t.stabs\t\"%s:r", t->u.l.nm);`
		1543	`OUT_DT_SHAPE ( t->u.l.dt ) ;`
		1544	`fprintf ( dg_file, "\",0x40,0,%d,%ld\n",0,24+ ((disp-68)/4));`
		1545	`}`
		1546	`break;`
		1547	`}`
		1548	`case D_LOCAL: {`
		1549	`long disp = t->u.l.offset;`
		1550	`fprintf ( dg_file, "\t.stabs\t\"%s:", t->u.l.nm);`
		1551	`OUT_DT_SHAPE ( t->u.l.dt ) ;`
		1552	`fprintf ( dg_file, "\",0x80,0,%d,%ld\n", 0, disp);`
		1553	`break;`
		1554	`}`
		1555	`default: {`
		1556	`fprintf ( dg_file, "\t.stabn\t0x%x,0,%d,.LL.%d-%s\n",`
		1557	`t->u.b.br, t->u.b.lev, t->u.b.lab, last_proc_lab );`
		1558	`}`
		1559	`}`
		1560	`}`
		1561	`c_del_array = del_stab_start;`
		1562	`c_del_index = 0;`
		1563	`}`
		1564	`return;`
		1565	`}`
		1566
		1567
		1568	`/*`
		1569	`OUTPUT DIAGNOSTICS FOR A LOCAL VARIABLE`
		1570	`*/`
		1571
		1572	`#ifdef NEWDIAGS`
		1573
		1574	`static void stab_local`
		1575	`PROTO_N ( ( di, param ) )`
		1576	`PROTO_T ( dg_name di X int param )`
		1577	`{`
		1578	`exp id = di->data.n_obj.obtain_val;`
		1579	`struct delay_stab * t;`
		1580	`char* nm;`
		1581	`dg_type dt;`
		1582	`long disp;`
		1583	`if (di->key != DGN_OBJECT \|\| !id)`
		1584	`return;`
		1585	`id = son(id);`
		1586	`if (name(id) == cont_tag && name(son(id)) == name_tag && isvar(son(son(id))))`
		1587	`id = son(id);`
		1588	`if (name(id) != name_tag \|\| isdiscarded(id) \|\| (isglob(son(id)) &&`
		1589	`no(son(id)) == 0 && !(brog(son(id))->dec_u.dec_val.extnamed)))`
		1590	`return;`
		1591	`disp = no(id);`
		1592	`id = son(id);`
		1593	`nm = idname_chars (di->idnam);`
		1594	`dt = di->data.n_obj.typ;`
		1595	`t = next_del_stab();`
		1596
		1597	`if (name (id) == ident_tag && ((props (id) & defer_bit) == 0))`
		1598	`disp += boff ( id ).offset ; /* is this condition right ? */`
		1599	`again :`
		1600	`if ( name ( id ) == ident_tag ) {`
		1601	`if ( ( props ( id ) & defer_bit ) == 0 ) {`
		1602	`/* +++ add assembler comment to say which reg is being used */`
		1603	`t->del_t = (param ? D_PARAM : D_LOCAL) ;`
		1604	`t->u.l.nm = nm ;`
		1605	`t->u.l.dt = dt ;`
		1606	`t->u.l.offset = disp;`
		1607	`return ;`
		1608	`}`
		1609	`else {`
		1610	`exp sn = son ( id ) ;`
		1611	`long d = disp ;`
		1612
		1613	`while ( sn != nilexp ) {`
		1614	`switch ( name ( sn ) ) {`
		1615	`case name_tag : {`
		1616	`disp = d + no ( sn ) ;`
		1617	`id = son ( sn ) ;`
		1618	`/* if ( isvar ( id ) ) dt = dt->data.ptr.object ; ?????????? */`
		1619	`goto again ;`
		1620	`}`
		1621	`case reff_tag : {`
		1622	`d += no ( sn ) ;`
		1623	`sn = son ( sn ) ;`
		1624	`break ;`
		1625	`}`
		1626	`case cont_tag : {`
		1627	`sn = son ( sn ) ;`
		1628	`break ;`
		1629	`}`
		1630	`default : {`
		1631	`return ;`
		1632	`}`
		1633	`}`
		1634	`}`
		1635	`}`
		1636	`}`
		1637	`return ;`
		1638	`}`
		1639
		1640	`#else`
		1641
		1642	`void stab_local`
		1643	`PROTO_N ( ( nm, dt, ldid, disp, findex ) )`
		1644	`PROTO_T ( char *nm X diag_type dt X exp ldid X long disp X long findex )`
		1645	`{`
		1646	`exp id = son ( ldid ) ;`
		1647	`struct delay_stab * t = next_del_stab();`
		1648
		1649	`if (name (id) == ident_tag && ((props (id) & defer_bit) == 0))`
		1650	`disp += boff ( id ).offset ; /* is this condition right ? */`
		1651	`again :`
		1652	`if ( name ( id ) == ident_tag ) {`
		1653	`if ( ( props ( id ) & defer_bit ) == 0 ) {`
		1654	`/* +++ add assembler comment to say which reg is being used */`
		1655	`if ( isparam ( id ) ) {`
		1656	`t->del_t = D_PARAM;`
		1657	`t->u.l.nm = nm ;`
		1658	`t->u.l.dt = dt ;`
		1659	`t->u.l.offset = disp;`
		1660	`return ;`
		1661	`}`
		1662	`else {`
		1663	`t->del_t = D_LOCAL;`
		1664	`t->u.l.nm = nm ;`
		1665	`t->u.l.dt = dt ;`
		1666	`t->u.l.offset = disp;`
		1667	`return ;`
		1668	`}`
		1669	`}`
		1670	`else {`
		1671	`exp sn = son ( id ) ;`
		1672	`long d = disp ;`
		1673
		1674	`while ( sn != nilexp ) {`
		1675	`switch ( name ( sn ) ) {`
		1676	`case name_tag : {`
		1677	`disp = d + no ( sn ) ;`
		1678	`id = son ( sn ) ;`
		1679	`if ( isvar ( id ) ) dt = dt->data.ptr.object ;`
		1680	`goto again ;`
		1681	`}`
		1682	`case reff_tag : {`
		1683	`d += no ( sn ) ;`
		1684	`sn = son ( sn ) ;`
		1685	`break ;`
		1686	`}`
		1687	`case cont_tag : {`
		1688	`sn = son ( sn ) ;`
		1689	`break ;`
		1690	`}`
		1691	`default : {`
		1692	`return ;`
		1693	`}`
		1694	`}`
		1695	`}`
		1696	`}`
		1697	`}`
		1698	`return ;`
		1699	`}`
		1700
		1701	`#endif`
		1702
		1703
		1704	`/*`
		1705	`DEAL WITH BASIC TYPES`
		1706	`*/`
		1707
		1708	`void stab_types`
		1709	`PROTO_Z ()`
		1710	`{`
		1711	`total_type_sizes = NO_STABS ;`
		1712	`typeno = NO_STABS ;`
		1713	`type_sizes = ( long * ) xmalloc ( NO_STABS * sizeof ( long ) ) ;`
		1714	`fputs ( "\t.stabs\t\"int:t1=r1;-2147483648;2147483647;\",0x80,0,0,0\n", dg_file ) ;`
		1715	`fputs ( "\t.stabs\t\"short int:t2=r1;-32768;32767;\",0x80,0,0,0\n",`
		1716	`dg_file ) ;`
		1717	`fputs ( "\t.stabs\t\"short unsigned int:t3=r1;0;65535;\",0x80,0,0,0\n", dg_file ) ;`
		1718	`fputs ( "\t.stabs\t\"char:t4=r4;0;127;\",0x80,0,0,0\n", dg_file ) ;`
		1719	`fputs ( "\t.stabs\t\"signed char:t5=r1;-128;127;\",0x80,0,0,0\n",`
		1720	`dg_file ) ;`
		1721	`fputs ( "\t.stabs\t\"unsigned char:t6=r1;0;255;\",0x80,0,0,0\n",`
		1722	`dg_file ) ;`
		1723	`fputs ( "\t.stabs\t\"long int:t7=r1;-2147483648;2147483647;\",0x80,0,0,0\n", dg_file ) ;`
		1724	`fputs ( "\t.stabs\t\"unsigned int:t8=r1;0;-1;\",0x80,0,0,0\n",`
		1725	`dg_file ) ;`
		1726	`fputs ( "\t.stabs\t\"long unsigned int:t9=r1;0;-1;\",0x80,0,0,0\n",`
		1727	`dg_file ) ;`
		1728	`fputs ( "\t.stabs\t\"float:t10=r1;4;0;\",0x80,0,0,0\n", dg_file ) ;`
		1729	`fputs ( "\t.stabs\t\"double:t11=r1;8;0;\",0x80,0,0,0\n", dg_file ) ;`
		1730	`fprintf ( dg_file, "\t.stabs\t\"long double:t12=r1;%ld;0;\",0x80,0,0,0\n",`
		1731	`DOUBLE_SZ / 8 ) ;`
		1732	`fputs ( "\t.stabs\t\"void:t13=13\",0x80,0,0,0\n", dg_file ) ;`
		1733	`fputs ( "\t.stabs\t\"long long int:t14=r1;", dg_file ) ;`
		1734	`fputs ( "01000000000000000000000;0777777777777777777777;\",0x80,0,0,0\n",`
		1735	`dg_file ) ;`
		1736	`fputs ( "\t.stabs\t\"unsigned long long int:t15=r1;", dg_file ) ;`
		1737	`fputs ( "0000000000000;01777777777777777777777;\",0x80,0,0,0\n",`
		1738	`dg_file ) ;`
		1739	`fputs ( "\t.stabs\t\"__void_star:t16=*13\",0x80,0,0,0\n",`
		1740	`dg_file ) ;`
		1741	`type_sizes [0] = 0 ;`
		1742	`type_sizes [1] = 32 ;`
		1743	`type_sizes [2] = 16 ;`
		1744	`type_sizes [3] = 16 ;`
		1745	`type_sizes [4] = 8 ;`
		1746	`type_sizes [5] = 8 ;`
		1747	`type_sizes [6] = 8 ;`
		1748	`type_sizes [7] = 32 ;`
		1749	`type_sizes [8] = 32 ;`
		1750	`type_sizes [9] = 32 ;`
		1751	`type_sizes [10] = 32 ;`
		1752	`type_sizes [11] = 64 ;`
		1753	`type_sizes [12] = DOUBLE_SZ ;`
		1754	`type_sizes [13] = 0 ;`
		1755	`type_sizes [14] = 64 ;`
		1756	`type_sizes [15] = 64 ;`
		1757	`type_sizes [16] = 32 ;`
		1758	`return ;`
		1759	`}`
		1760
		1761
		1762
		1763	`#ifndef NEWDIAGS`
		1764
		1765	`/*`
		1766	`DEAL WITH STRUCTURE, UNION AND ENUM TAGS`
		1767	`*/`
		1768
		1769	`void stab_tagdefs`
		1770	`PROTO_Z ()`
		1771	`{`
		1772	`diag_tagdef **di = unit_ind_diagtags ;`
		1773	`int i, n = unit_no_of_diagtags, istag ;`
		1774
		1775	`for ( i = 0 ; i < n ; i++ ) {`
		1776	`diag_type d = di [i]->d_type ;`
		1777	`istag = 1;`
		1778
		1779	`switch ( d->key ) {`
		1780
		1781	`case DIAG_TYPE_STRUCT : {`
		1782	`char *nme = d->data.t_struct.nme.ints.chars ;`
		1783	`if ( nme && *nme ) {`
		1784	`fprintf ( dg_file, "\t.stabs\t\"%s:", nme ) ;`
		1785	`} else {`
		1786	`static int s_count = 0 ;`
		1787	`fprintf ( dg_file, "\t.stabs\t\"_struct%d:", s_count++ ) ;`
		1788	`}`
		1789	`break ;`
		1790	`}`
		1791	`case DIAG_TYPE_UNION : {`
		1792	`char *nme = d->data.t_union.nme.ints.chars ;`
		1793	`if ( nme && *nme ) {`
		1794	`fprintf ( dg_file, "\t.stabs\t\"%s:", nme ) ;`
		1795	`} else {`
		1796	`static int u_count = 0 ;`
		1797	`fprintf ( dg_file, "\t.stabs\t\"_union%d:", u_count++ ) ;`
		1798	`}`
		1799	`break ;`
		1800	`}`
		1801	`case DIAG_TYPE_ENUM : {`
		1802	`char *nme = d->data.t_enum.nme.ints.chars ;`
		1803	`if ( nme && *nme ) {`
		1804	`fprintf ( dg_file, "\t.stabs\t\"%s:", nme ) ;`
		1805	`} else {`
		1806	`static int e_count = 0 ;`
		1807	`fprintf ( dg_file, "\t.stabs\t\"_enum%d:", e_count++ ) ;`
		1808	`}`
		1809	`break ;`
		1810	`}`
		1811	`default: {`
		1812	`istag = 0 ;`
		1813	`break ;`
		1814	`}`
		1815	`}`
		1816	`if (istag) {`
		1817	`if ( d->been_outed && 0) {`
		1818	`fprintf ( dg_file, "%d", (int)d->been_outed ) ;`
		1819	`} else {`
		1820	`fprintf ( dg_file, "T" ) ;`
		1821	`OUT_DT_SHAPE ( d ) ;`
		1822	`}`
		1823	`fprintf ( dg_file, "\",0x80,0,0,0\n" ) ;`
		1824	`}`
		1825	`}`
		1826	`return ;`
		1827	`}`
		1828
		1829	`#endif`
		1830
		1831
		1832	`/*`
		1833	`DEAL WITH TYPEDEFS`
		1834	`*/`
		1835
		1836	`#ifndef NEWDIAGS`
		1837
		1838	`void stab_typedefs`
		1839	`PROTO_Z ()`
		1840	`{`
		1841	`diag_descriptor *di = unit_diagvar_tab.array ;`
		1842	`int i, n = unit_diagvar_tab.lastused ;`
		1843	`for ( i = 0 ; i < n ; i++ ) {`
		1844	`if ( di [i].key == DIAG_TYPEDEF_KEY ) {`
		1845	`long non = next_typen () ;`
		1846	`fprintf ( dg_file, "\t.stabs\t\"%s:t%ld=",`
		1847	`di [i].data.typ.nme.ints.chars, non ) ;`
		1848	`OUT_DT_SHAPE ( di [i].data.typ.new_type ) ;`
		1849	`fprintf ( dg_file, "\",0x80,0,0,0\n" ) ;`
		1850	`}`
		1851	`}`
		1852	`return ;`
		1853	`}`
		1854
		1855	`#endif`
		1856
		1857
		1858
		1859	`/*`
		1860	`INITIALISE DIAGNOSTICS`
		1861	`*/`
		1862
		1863	`#ifdef NEWDIAGS`
		1864
		1865	`void init_stab`
		1866	`PROTO_Z ()`
		1867	`{`
		1868	`return;`
		1869	`}`
		1870
		1871	`void init_stab_aux`
		1872	`PROTO_Z ()`
		1873	`{`
		1874	`dg_compilation this_comp;`
		1875	`dg_file = as_file ;`
		1876	`this_comp = all_comp_units;`
		1877	`while (this_comp) {`
		1878	`dg_name item = this_comp->dn_list;`
		1879	`while (item) {`
		1880	`if (item->key == DGN_PROC && item->data.n_proc.obtain_val)`
		1881	`prim_file = this_comp->prim_file;`
		1882	`item = item -> next;`
		1883	`}`
		1884	`this_comp = this_comp->another;`
		1885	`}`
		1886	`if (prim_file)`
		1887	`stab_file (prim_file);`
		1888	`stab_types () ;`
		1889	`#if 0`
		1890	`this_comp = all_comp_units;`
		1891	`while (this_comp) {`
		1892	`dg_name item = this_comp->dn_list;`
		1893	`while (item) {`
		1894	`if (item->key == DGN_TYPE) {`
		1895	`dg_type dt = item->data.n_typ.raw;`
		1896	`char * s = idname_chars (item->idnam);`
		1897	`if (s[0]) {`
		1898	`if (!dt->outref.k) {`
		1899	`dt->outref.k = -1;`
		1900	`dt->outref.u.l = next_typen () ;`
		1901	`if (dt->key == DGT_STRUCT)`
		1902	`shape_stab_size (dt->outref.u.l, dt->data.t_struct.sha);`
		1903	`else`
		1904	`if (dt->key == DGT_ENUM)`
		1905	`shape_stab_size (dt->outref.u.l, dt->data.t_enum.sha);`
		1906	`}`
		1907	`}`
		1908	`else`
		1909	`if ((dt->key == DGT_STRUCT &&`
		1910	`(dt->data.t_struct.idnam.id_key == DG_ID_SRC \|\|`
		1911	`dt->data.t_struct.idnam.id_key == DG_ID_EXT)`
		1912	`&& (s = dt->data.t_struct.idnam.idd.nam, s[0]))`
		1913	`\|\| (dt->key == DGT_ENUM && (s = dt->data.t_enum.tnam, s[0]))) {`
		1914	`if (!dt->outref.k) {`
		1915	`dt->outref.k = -1;`
		1916	`dt->outref.u.l = next_typen () ;`
		1917	`if (dt->key == DGT_STRUCT)`
		1918	`shape_stab_size (dt->outref.u.l, dt->data.t_struct.sha);`
		1919	`else`
		1920	`if (dt->key == DGT_ENUM)`
		1921	`shape_stab_size (dt->outref.u.l, dt->data.t_enum.sha);`
		1922	`}`
		1923	`}`
		1924	`}`
		1925	`item = item -> next;`
		1926	`}`
		1927	`this_comp = this_comp->another;`
		1928	`}`
		1929	`#endif`
		1930	`this_comp = all_comp_units;`
		1931	`while (this_comp) {`
		1932	`dg_name item = this_comp->dn_list;`
		1933	`while (item) {`
		1934	`if (item->key == DGN_TYPE && item->data.n_typ.raw->key != DGT_UNKNOWN) {`
		1935	`dg_type dt = item->data.n_typ.raw;`
		1936	`char * s = idname_chars (item->idnam);`
		1937	`if (s[0]) {`
		1938	`fprintf ( dg_file, "\t.stabs\t\"%s:", s ) ;`
		1939	`if (dt->outref.k == LAB_STR) {`
		1940	`dt->outref.k = LAB_D;`
		1941	`dt->outref.u.l = find_basic_type (dt->outref.u.s);`
		1942	`}`
		1943	`if ( dt->outref.k == LAB_D ) {`
		1944	`fprintf ( dg_file, "%d", (int)dt->outref.u.l ) ;`
		1945	`} else {`
		1946	`fprintf ( dg_file, "t" ) ;`
		1947	`OUT_DT_SHAPE ( dt ) ;`
		1948	`}`
		1949	`fprintf ( dg_file, "\",0x80,0,0,0\n" ) ;`
		1950	`}`
		1951	`else`
		1952	`if ((dt->key == DGT_STRUCT &&`
		1953	`(dt->data.t_struct.idnam.id_key == DG_ID_SRC \|\|`
		1954	`dt->data.t_struct.idnam.id_key == DG_ID_EXT)`
		1955	`&& (s = dt->data.t_struct.idnam.idd.nam, s[0]))`
		1956	`\|\| (dt->key == DGT_ENUM && (s = dt->data.t_enum.tnam, s[0]))) {`
		1957	`fprintf ( dg_file, "\t.stabs\t\"%s:", s ) ;`
		1958	`if ( dt->outref.k == LAB_D ) {`
		1959	`fprintf ( dg_file, "%d", (int)dt->outref.u.l ) ;`
		1960	`} else {`
		1961	`fprintf ( dg_file, "T" ) ;`
		1962	`OUT_DT_SHAPE ( dt ) ;`
		1963	`}`
		1964	`fprintf ( dg_file, "\",0x80,0,0,0\n" ) ;`
		1965	`}`
		1966	`#if 0`
		1967	`if (item->mor && item->mor->this_tag)`
		1968	`item->mor->this_tag->outref = item->data.n_typ.raw->outref;`
		1969	`#endif`
		1970	`}`
		1971	`item = item -> next;`
		1972	`}`
		1973	`this_comp = this_comp->another;`
		1974	`}`
		1975	`return;`
		1976	`}`
		1977
		1978	`#else`
		1979
		1980	`void init_stab`
		1981	`PROTO_Z ()`
		1982	`{`
		1983	`dg_file_name = tmpnam ( NULL ) ;`
		1984	`dg_file = fopen ( dg_file_name, "w" ) ;`
		1985	`if ( dg_file == NULL ) {`
		1986	`fail ( "Can't open temporary diagnostics file" ) ;`
		1987	`exit ( EXIT_FAILURE ) ;`
		1988	`}`
		1989	`stab_types () ;`
		1990	`return ;`
		1991	`}`
		1992
		1993	`void init_stab_aux`
		1994	`PROTO_Z ()`
		1995	`{`
		1996	`int c ;`
		1997	`FILE *f ;`
		1998	`int i, j = 0 ;`
		1999	`for ( i = 0 ; i < nofds ; i++ ) {`
		2000	`char *s = fds [i]->file.ints.chars ;`
		2001	`int n = ( int ) strlen ( s ) ;`
		2002	`if ( n && s [ n - 1 ] != 'h' ) j = i ;`
		2003	`}`
		2004	`fclose ( dg_file ) ;`
		2005	`dg_file = as_file ;`
		2006	`stab_file ( ( long ) j, 0 ) ;`
		2007	`f = fopen ( dg_file_name, "r" ) ;`
		2008	`if ( f == NULL ) {`
		2009	`fail ( "Can't open temporary diagnostics file" ) ;`
		2010	`exit ( EXIT_FAILURE ) ;`
		2011	`}`
		2012	`while ( c = fgetc ( f ), c != EOF ) outc ( c ) ;`
		2013	`fclose ( f ) ;`
		2014	`remove ( dg_file_name ) ;`
		2015	`return ;`
		2016	`}`
		2017
		2018	`#endif`
		2019
		2020

Subversion Repositories tendra.SVN

(root)/branches/tendra4/src/installers/sparc/solaris/sparcdiags.c – Rev 2