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

Subversion Repositories tendra.SVN

(root)/trunk/src/installers/80x86/solaris/diag_out.c – Rev 2