[unix-history] / usr / src / cmd / c / c13.c

/*
 * C second pass -- tables
 */
#include "c1.h"
/*
 * Operator dope table-- see description in c0.
 */
int opdope[] {
	000000,	/* EOFC */
	000000,	/* ; */
	000000,	/* { */
	000000,	/* } */
	036000,	/* [ */
	002000,	/* ] */
	036000,	/* ( */
	002000,	/* ) */
	014201,	/* : */
	007001,	/* , */
	000000,	/* field selection */
	000000,	/* reverse field selection */
	000001,	/* temporary field selection */
	000001,	/* int->ptr */
	000001,	/* ptr->int */
	000001,	/* long->ptr */
	000001,	/* field assignment */
	000001,	/* >> unsigned */
	000001,	/* >> unsigned */
	000000,	/* 19 */
	000400,	/* name */
	000400,	/* short constant */
	000400,	/* string */
	000400,	/* float */
	000400,	/* double */
	0000400,	/* long const */
	000400,	/* long const <= 16 bits */
	000400,	/* autoi, *r++ */
	000400,	/* autod, *--r */
	000000,	/* 29 */
	034203,	/* ++pre */
	034203,	/* --pre */
	034203,	/* ++post */
	034203,	/* --post */
	034220,	/* !un */
	034202,	/* &un */
	034220,	/* *un */
	034200,	/* -un */
	034220,	/* ~un */
	036001,	/* . (structure reference) */
	030101,	/* + */
	030001,	/* - */
	032101,	/* * */
	032001,	/* / */
	032001,	/* % */
	026061,	/* >> */
	026061,	/* << */
	020161,	/* & */
	016161,	/* | */
	016161,	/* ^ */
	036001,	/* -> */
	001000,	/* int -> double */
	001000,	/* double -> int */
	000001,	/* && */
	000001,	/* || */
	030001, /* &~ */
	001000,	/* double -> long */
	001000,	/* long -> double */
	001000,	/* integer -> long */
	000000,	/* long -> integer */
	022005,	/* == */
	022005,	/* != */
	024005,	/* <= */
	024005,	/* < */
	024005,	/* >= */
	024005,	/* > */
	024005,	/* <p */
	024005,	/* <=p */
	024005,	/* >p */
	024005,	/* >=p */
	012213,	/* =+ */
	012213,	/* =- */
	012213,	/* =* */
	012213,	/* =/ */
	012213,	/* =% */
	012253,	/* =>> */
	012253,	/* =<< */
	012253,	/* =& */
	012253,	/* =| */
	012253,	/* =^ */
	012213,	/* = */
	030001, /* & for tests */
	032001,	/*  * (long) */
	032001,	/*  / (long) */
	032001,	/* % (long) */
	012253,	/* =& ~ */
	012213,	/* =* (long) */
	012213,	/* / (long) */
	012213,	/* % (long) */
	000000,	/* 89 */
	014201,	/* ? */
	026061,	/* long << */
	012253,	/* long =<< */
	000101,	/* max */
	000101,	/* maxp */
	000101,	/* min */
	000101,	/* minp */
	000001,	/* , */
	000000,	/* 98 */
	000000,	/* 99 */
	036001,	/* call */
	036000,	/* mcall */
	000000,	/* goto */
	000000,	/* jump cond */
	000000,	/* branch cond */
	000400,	/* set nregs */
	000000, /* 106 */
	000000,	/* 107 */
	000000,	/* 108 */
	000000,	/* int->char */
	000000,	/* force r0 */
	000000,	/* 111 */
	000000,	/* 112 */
	000000,	/* 113 */
	000000,	/* 114 */
	000000,	/* structure assign */
	000001,	/* struct assignment setup */
};

char	*opntab[] {
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	0,
	":",
	",",
	"field select",
	0,
	0,
	"int->ptr",
	"ptr->int",
	"long->ptr",
	"field assign",
	">>",
	">>",
	0,
	"name",
	"short constant",
	"string",
	"float",
	"double",
	"long constant",
	"long constant",
	"*r++",
	"*--r",
	0,
	"++pre",
	"--pre",
	"++post",
	"--post",
	"!un",
	"&",
	"*",
	"-",
	"~",
	".",
	"+",
	"-",
	"*",
	"/",
	"%",
	">>",
	"<<",
	"&",
	"|",
	"^",
	"->",
	"int->double",
	"double->int",
	"&&",
	"||",
	"&~",
	"double->long",
	"long->double",
	"integer->long",
	"long->integer",
	"==",
	"!=",
	"<=",
	"<",
	">=",
	">",
	"<p",
	"<=p",
	">p",
	">=p",
	"+=",
	"-=",
	"*=",
	"/=",
	"%=",
	">>=",
	"<<=",
	"&=",
	"|=",
	"^=",
	"=",
	"& for tests",
	"*",
	"/",
	"%",
	"&= ~",
	"*=",
	"/=",
	"%=",
	0,
	"?",
	"<<",
	"<<=",
	"\\/",
	"\\/",
	"/\\",
	"/\\",
	0,
	"call",
	"call",
	"call",
	0,
	"goto",
	"jump cond",
	"branch cond",
	"set nregs",
	"load value",
	0,
	0,
	"int->char",
	"force register",
	"",
	"",
	"",
	"",
	"=structure",
	"= (struct setup)",
};

/*
 * Strings for instruction tables.
 */
char	mov[]	"mov";
char	clr[]	"clr";
char	cmp[]	"cmp";
char	tst[]	"tst";
char	add[]	"add";
char	sub[]	"sub";
char	inc[]	"inc";
char	dec[]	"dec";
char	mul[]	"mul";
char	div[]	"div";
char	asr[]	"asr";
char	ash[]	"ash";
char	asl[]	"asl";
char	bic[]	"bic";
char	bic1[]	"bic $1,";
char	bit[]	"bit";
char	bit1[]	"bit $1,";
char	bis[]	"bis";
char	bis1[]	"bis $1,";
char	xor[]	"xor";
char	neg[]	"neg";
char	com[]	"com";
char	stdol[]	"*$";
char	ashc[]	"ashc";
char	slmul[]	"lmul";
char	sldiv[]	"ldiv";
char	slrem[]	"lrem";
char	almul[]	"almul";
char	aldiv[]	"aldiv";
char	alrem[]	"alrem";
char	jeq[]	"jeq";
char	jne[]	"jne";
char	jle[]	"jle";
char	jgt[]	"jgt";
char	jlt[]	"jlt";
char	jge[]	"jge";
char	jlos[]	"jlos";
char	jhi[]	"jhi";
char	jlo[]	"jlo";
char	jhis[]	"jhis";
char	nop[]	"/nop";
char	jbr[]	"jbr";

/*
 * Instruction tables, accessed by
 * I (first operand) or I' (second) macros.
 */

struct instab instab[] {
	LOAD,	mov,	tst,
	ASSIGN,	mov,	clr,
	EQUAL,	cmp,	tst,
	NEQUAL,	cmp,	tst,
	LESSEQ,	cmp,	tst,
	LESS,	cmp,	tst,
	GREATEQ,cmp,	tst,
	GREAT,	cmp,	tst,
	LESSEQP,cmp,	tst,
	LESSP,	cmp,	tst,
	GREATQP,cmp,	tst,
	GREATP,	cmp,	tst,
	PLUS,	add,	inc,
	ASPLUS,	add,	inc,
	MINUS,	sub,	dec,
	ASMINUS,sub,	dec,
	INCBEF,	add,	inc,
	DECBEF,	sub,	dec,
	INCAFT,	add,	inc,
	DECAFT,	sub,	dec,
	TIMES,	mul,	mul,
	ASTIMES,mul,	mul,
	DIVIDE,	div,	div,
	ASDIV,	div,	div,
	MOD,	div,	div,
	ASMOD,	div,	div,
	PTOI,	div,	div,
	RSHIFT,	ash,	asr,
	ASRSH,	ash,	asr,
	LSHIFT,	ash,	asl,
	ASLSH,	ash,	asl,
	AND,	bic,	bic1,
	ANDN,	bic,	bic1,
	ASANDN,	bic,	bic1,
	TAND,	bit,	bit1,
	OR,	bis,	bis1,
	ASOR,	bis,	bis1,
	EXOR,	xor,	xor,
	ASXOR,	xor,	xor,
	NEG,	neg,	neg,
	COMPL,	com,	com,
	CALL1,	stdol,	stdol,
	CALL2,	"",	"",
	LLSHIFT,ashc,	ashc,
	ASLSHL,	ashc,	ashc,
	LTIMES,	slmul,	slmul,
	LDIV,	sldiv,	sldiv,
	LMOD,	slrem,	slrem,
	LASTIMES,almul,	almul,
	LASDIV,	aldiv,	aldiv,
	LASMOD,	alrem,	alrem,
	ULSH,	ashc,	ashc,
	ASULSH,	ashc,	ashc,
	0,	0,	0};

/*
 * Similar table for relationals.
 * The first string is for the positive
 * test, the second for the inverted one.
 * The '200+' entries are 
 * used in tests against 0 where a 'tst'
 * instruction is used; it clears the c-bit
 * the c-bit so ptr tests are funny.
 */
struct instab branchtab[] {
	EQUAL,	jeq,	jne,
	NEQUAL,	jne,	jeq,
	LESSEQ,	jle,	jgt,
	LESS,	jlt,	jge,
	GREATEQ,jge,	jlt,
	GREAT,	jgt,	jle,
	LESSEQP,jlos,	jhi,
	LESSP,	jlo,	jhis,
	GREATQP,jhis,	jlo,
	GREATP,	jhi,	jlos,
	200+EQUAL,	jeq,	jne,
	200+NEQUAL,	jne,	jeq,
	200+LESSEQ,	jle,	jgt,
	200+LESS,	jlt,	jge,
	200+GREATEQ,	jge,	jlt,
	200+GREAT,	jgt,	jle,
	200+LESSEQP,	jeq,	jne,
	200+LESSP,	nop,	jbr,
	200+GREATQP,	jbr,	nop,
	200+GREATP,	jne,	jeq,
	0,	0,	0 };
Commit	Line	Data
1a3b21a9 DR	1	/*
	2	* C second pass -- tables
	3	*/
	4	#include "c1.h"
	5	/*
	6	* Operator dope table-- see description in c0.
	7	*/
	8	int opdope[] {
	9	000000, /* EOFC */
	10	000000, /* ; */
	11	000000, /* { */
	12	000000, /* } */
	13	036000, /* [ */
	14	002000, /* ] */
	15	036000, /* ( */
	16	002000, /* ) */
	17	014201, /* : */
	18	007001, /* , */
	19	000000, /* field selection */
	20	000000, /* reverse field selection */
	21	000001, /* temporary field selection */
	22	000001, /* int->ptr */
	23	000001, /* ptr->int */
	24	000001, /* long->ptr */
	25	000001, /* field assignment */
	26	000001, /* >> unsigned */
	27	000001, /* >> unsigned */
	28	000000, /* 19 */
	29	000400, /* name */
	30	000400, /* short constant */
	31	000400, /* string */
	32	000400, /* float */
	33	000400, /* double */
	34	0000400, /* long const */
	35	000400, /* long const <= 16 bits */
	36	000400, /* autoi, r++ /
	37	000400, /* autod, --r /
	38	000000, /* 29 */
	39	034203, /* ++pre */
	40	034203, /* --pre */
	41	034203, /* ++post */
	42	034203, /* --post */
	43	034220, /* !un */
	44	034202, /* &un */
	45	034220, /* un /
	46	034200, /* -un */
	47	034220, /* ~un */
	48	036001, /* . (structure reference) */
	49	030101, /* + */
	50	030001, /* - */
	51	032101, /* * */
	52	032001, /* / */
	53	032001, /* % */
	54	026061, /* >> */
	55	026061, /* << */
	56	020161, /* & */
	57	016161, /* \| */
	58	016161, /* ^ */
	59	036001, /* -> */
	60	001000, /* int -> double */
	61	001000, /* double -> int */
	62	000001, /* && */
	63	000001, /* \|\| */
	64	030001, /* &~ */
65	001000, /* double -> long */
66	001000, /* long -> double */
67	001000, /* integer -> long */
68	000000, /* long -> integer */
69	022005, /* == */
70	022005, /* != */
71	024005, /* <= */
72	024005, /* < */
73	024005, /* >= */
74	024005, /* > */
75	024005, /* <p */
76	024005, /* <=p */
77	024005, /* >p */
78	024005, /* >=p */
79	012213, /* =+ */
80	012213, /* =- */
81	012213, /* =* */
82	012213, /* =/ */
83	012213, /* =% */
84	012253, /* =>> */
85	012253, /* =<< */
86	012253, /* =& */
87	012253, /* =\| */
88	012253, /* =^ */
89	012213, /* = */
90	030001, /* & for tests */
91	032001, /* * (long) */
92	032001, /* / (long) */
93	032001, /* % (long) */
94	012253, /* =& ~ */
95	012213, /* =* (long) */
96	012213, /* / (long) */
97	012213, /* % (long) */
98	000000, /* 89 */
99	014201, /* ? */
100	026061, /* long << */
101	012253, /* long =<< */
102	000101, /* max */
103	000101, /* maxp */
104	000101, /* min */
105	000101, /* minp */
106	000001, /* , */
107	000000, /* 98 */
108	000000, /* 99 */
109	036001, /* call */
110	036000, /* mcall */
111	000000, /* goto */
112	000000, /* jump cond */
113	000000, /* branch cond */
114	000400, /* set nregs */
115	000000, /* 106 */
116	000000, /* 107 */
117	000000, /* 108 */
118	000000, /* int->char */
119	000000, /* force r0 */
120	000000, /* 111 */
121	000000, /* 112 */
122	000000, /* 113 */
123	000000, /* 114 */
124	000000, /* structure assign */
125	000001, /* struct assignment setup */
126	};
127
128	char *opntab[] {
129	0,
130	0,
131	0,
132	0,
133	0,
134	0,
135	0,
136	0,
137	":",
138	",",
139	"field select",
140	0,
141	0,
142	"int->ptr",
143	"ptr->int",
144	"long->ptr",
145	"field assign",
146	">>",
147	">>",
148	0,
149	"name",
150	"short constant",
151	"string",
152	"float",
153	"double",
154	"long constant",
155	"long constant",
156	"*r++",
157	"*--r",
158	0,
159	"++pre",
160	"--pre",
161	"++post",
162	"--post",
163	"!un",
164	"&",
165	"*",
166	"-",
167	"~",
168	".",
169	"+",
170	"-",
171	"*",
172	"/",
173	"%",
174	">>",
175	"<<",
176	"&",
177	"\|",
178	"^",
179	"->",
180	"int->double",
181	"double->int",
182	"&&",
183	"\|\|",
184	"&~",
185	"double->long",
186	"long->double",
187	"integer->long",
188	"long->integer",
189	"==",
190	"!=",
191	"<=",
192	"<",
193	">=",
194	">",
195	"<p",
196	"<=p",
197	">p",
198	">=p",
199	"+=",
200	"-=",
201	"*=",
202	"/=",
203	"%=",
204	">>=",
205	"<<=",
206	"&=",
207	"\|=",
208	"^=",
209	"=",
210	"& for tests",
211	"*",
212	"/",
213	"%",
214	"&= ~",
215	"*=",
216	"/=",
217	"%=",
218	0,
219	"?",
220	"<<",
221	"<<=",
222	"\\/",
223	"\\/",
224	"/\\",
225	"/\\",
226	0,
227	"call",
228	"call",
229	"call",
230	0,
231	"goto",
232	"jump cond",
233	"branch cond",
234	"set nregs",
235	"load value",
236	0,
237	0,
238	"int->char",
239	"force register",
240	"",
241	"",
242	"",
243	"",
244	"=structure",
245	"= (struct setup)",
246	};
247
248	/*
249	* Strings for instruction tables.
250	*/
251	char mov[] "mov";
252	char clr[] "clr";
253	char cmp[] "cmp";
254	char tst[] "tst";
255	char add[] "add";
256	char sub[] "sub";
257	char inc[] "inc";
258	char dec[] "dec";
259	char mul[] "mul";
260	char div[] "div";
261	char asr[] "asr";
262	char ash[] "ash";
263	char asl[] "asl";
264	char bic[] "bic";
265	char bic1[] "bic $1,";
266	char bit[] "bit";
267	char bit1[] "bit $1,";
268	char bis[] "bis";
269	char bis1[] "bis $1,";
270	char xor[] "xor";
271	char neg[] "neg";
272	char com[] "com";
273	char stdol[] "*$";
274	char ashc[] "ashc";
275	char slmul[] "lmul";
276	char sldiv[] "ldiv";
277	char slrem[] "lrem";
278	char almul[] "almul";
279	char aldiv[] "aldiv";
280	char alrem[] "alrem";
281	char jeq[] "jeq";
282	char jne[] "jne";
283	char jle[] "jle";
284	char jgt[] "jgt";
285	char jlt[] "jlt";
286	char jge[] "jge";
287	char jlos[] "jlos";
288	char jhi[] "jhi";
289	char jlo[] "jlo";
290	char jhis[] "jhis";
291	char nop[] "/nop";
292	char jbr[] "jbr";
293
294	/*
295	* Instruction tables, accessed by
296	* I (first operand) or I' (second) macros.
297	*/
298
299	struct instab instab[] {
300	LOAD, mov, tst,
301	ASSIGN, mov, clr,
302	EQUAL, cmp, tst,
303	NEQUAL, cmp, tst,
304	LESSEQ, cmp, tst,
305	LESS, cmp, tst,
306	GREATEQ,cmp, tst,
307	GREAT, cmp, tst,
308	LESSEQP,cmp, tst,
309	LESSP, cmp, tst,
310	GREATQP,cmp, tst,
311	GREATP, cmp, tst,
312	PLUS, add, inc,
313	ASPLUS, add, inc,
314	MINUS, sub, dec,
315	ASMINUS,sub, dec,
316	INCBEF, add, inc,
317	DECBEF, sub, dec,
318	INCAFT, add, inc,
319	DECAFT, sub, dec,
320	TIMES, mul, mul,
321	ASTIMES,mul, mul,
322	DIVIDE, div, div,
323	ASDIV, div, div,
324	MOD, div, div,
325	ASMOD, div, div,
326	PTOI, div, div,
327	RSHIFT, ash, asr,
328	ASRSH, ash, asr,
329	LSHIFT, ash, asl,
330	ASLSH, ash, asl,
331	AND, bic, bic1,
332	ANDN, bic, bic1,
333	ASANDN, bic, bic1,
334	TAND, bit, bit1,
335	OR, bis, bis1,
336	ASOR, bis, bis1,
337	EXOR, xor, xor,
338	ASXOR, xor, xor,
339	NEG, neg, neg,
340	COMPL, com, com,
341	CALL1, stdol, stdol,
342	CALL2, "", "",
343	LLSHIFT,ashc, ashc,
344	ASLSHL, ashc, ashc,
345	LTIMES, slmul, slmul,
346	LDIV, sldiv, sldiv,
347	LMOD, slrem, slrem,
348	LASTIMES,almul, almul,
349	LASDIV, aldiv, aldiv,
350	LASMOD, alrem, alrem,
351	ULSH, ashc, ashc,
352	ASULSH, ashc, ashc,
353	0, 0, 0};
354
355	/*
356	* Similar table for relationals.
357	* The first string is for the positive
358	* test, the second for the inverted one.
359	* The '200+' entries are
360	* used in tests against 0 where a 'tst'
361	* instruction is used; it clears the c-bit
362	* the c-bit so ptr tests are funny.
363	*/
364	struct instab branchtab[] {
365	EQUAL, jeq, jne,
366	NEQUAL, jne, jeq,
367	LESSEQ, jle, jgt,
368	LESS, jlt, jge,
369	GREATEQ,jge, jlt,
370	GREAT, jgt, jle,
371	LESSEQP,jlos, jhi,
372	LESSP, jlo, jhis,
373	GREATQP,jhis, jlo,
374	GREATP, jhi, jlos,
375	200+EQUAL, jeq, jne,
376	200+NEQUAL, jne, jeq,
377	200+LESSEQ, jle, jgt,
378	200+LESS, jlt, jge,
379	200+GREATEQ, jge, jlt,
380	200+GREAT, jgt, jle,
381	200+LESSEQP, jeq, jne,
382	200+LESSP, nop, jbr,
383	200+GREATQP, jbr, nop,
384	200+GREATP, jne, jeq,
385	0, 0, 0 };