WebSVN – tendra.SVN – Blame – /branches/tendra5-amd64/src/installers/sparc/solaris/sparcdiags.c

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

Subversion Repositories tendra.SVN

(root)/branches/tendra5-amd64/src/installers/sparc/solaris/sparcdiags.c – Rev 6