Context Navigation

source: mainline/uspace/app/pcc/arch/pdp11/table.c@ 6037308

Visit:

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export

Last change on this file since 6037308 was a7de7182, checked in by Jiří Zárevúcky <zarevucky.jiri@…>, 14 years ago
Added pcc source tree (contents of pcc-1.0.0.tgz)
Property mode set to `100644`
File size: 17.1 KB

Line
1	/* $Id: table.c,v 1.5 2008/10/19 15:25:25 ragge Exp $ */
2	/*
3	* Copyright (c) 2003 Anders Magnusson (ragge@ludd.luth.se).
4	* All rights reserved.
5	*
6	* Redistribution and use in source and binary forms, with or without
7	* modification, are permitted provided that the following conditions
8	* are met:
9	* 1. Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.
11	* 2. Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.
14	* 3. The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission
16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/
28
29
30	# include "pass2.h"
31
32	# define TLL TLONGLONG\|TULONGLONG
33	# define ANYSIGNED TINT\|TLONG\|TSHORT\|TCHAR
34	# define ANYUSIGNED TUNSIGNED\|TULONG\|TUSHORT\|TUCHAR
35	# define ANYFIXED ANYSIGNED\|ANYUSIGNED
36	# define TUWORD TUNSIGNED
37	# define TSWORD TINT
38	# define TWORD TUWORD\|TSWORD
39	# define ANYSH SCON\|SAREG\|SOREG\|SNAME
40	# define ARONS SAREG\|SOREG\|SNAME\|STARNM
41
42	struct optab table[] = {
43	/* First entry must be an empty entry */
44	{ -1, FOREFF, SANY, TANY, SANY, TANY, 0, 0, "", },
45
46	/* PCONVs are usually not necessary */
47	{ PCONV, INAREG,
48	SAREG, TWORD\|TPOINT,
49	SAREG, TWORD\|TPOINT,
50	0, RLEFT,
51	"", },
52
53	/* convert char to int or unsigned */
54	{ SCONV, INAREG,
55	SAREG, TCHAR,
56	SAREG, TINT\|TUNSIGNED,
57	NAREG\|NASL, RESC1,
58	"", }, /* chars are stored as ints in registers */
59
60	{ SCONV, INAREG,
61	SOREG\|SCON\|SNAME, TCHAR,
62	SAREG, TINT,
63	NAREG\|NASL, RESC1,
64	"movb AL,A1\n", },
65
66	/* convert uchar to int or unsigned */
67	{ SCONV, INAREG,
68	SAREG\|SOREG\|SCON\|SNAME, TUCHAR,
69	SAREG, TINT\|TUNSIGNED,
70	NAREG, RESC1,
71	"clr A1\nbisb AL,A1\n", },
72
73	/* convert (u)int to (u)char. Nothing to do. */
74	{ SCONV, INAREG,
75	SAREG, TWORD,
76	SANY, TCHAR\|TUCHAR,
77	0, RLEFT,
78	"", },
79
80	/* convert (u)int to (u)int */
81	{ SCONV, INAREG,
82	SAREG, TWORD,
83	SANY, TWORD,
84	0, RLEFT,
85	"", },
86
87	/* convert pointer to (u)int */
88	{ SCONV, INAREG,
89	SAREG, TPOINT,
90	SANY, TWORD,
91	0, RLEFT,
92	"", },
93
94	/* convert int to long from memory */
95	{ SCONV, INBREG,
96	SNAME\|SOREG, TINT,
97	SANY, TLONG,
98	NBREG, RESC1,
99	"mov AL,U1\nsxt A1\n", },
100
101	/* int -> (u)long. XXX - only in r0 and r1 */
102	{ SCONV, INBREG,
103	SAREG, TINT,
104	SANY, TLONG\|TULONG,
105	NSPECIAL\|NBREG\|NBSL, RESC1,
106	"tst AL\nsxt r0\n", },
107
108	/* unsigned -> (u)long. XXX - only in r0 and r1 */
109	{ SCONV, INBREG,
110	SAREG, TUNSIGNED,
111	SANY, TLONG\|TULONG,
112	NSPECIAL\|NBREG\|NBSL, RESC1,
113	"clr r0\n", },
114
115	/* uint -> double */
116	{ SCONV, INCREG,
117	SAREG\|SNAME\|SOREG\|SCON, TUNSIGNED,
118	SANY, TFLOAT\|TDOUBLE,
119	NCREG\|NCSL, RESC1,
120	"mov AL,-(sp)\nclr -(sp)\n"
121	"setl\nmovif (sp)+,A1\nseti\n", },
122
123	/* long -> int */
124	{ SCONV, INAREG,
125	SBREG\|SOREG\|SNAME, TLONG\|TULONG,
126	SAREG, TWORD,
127	NAREG\|NASL, RESC1,
128	"mov UL,A1\n", },
129
130
131	/* (u)long -> (u)long, nothing */
132	{ SCONV, INBREG,
133	SBREG, TLONG\|TULONG,
134	SANY, TLONG\|TULONG,
135	NBREG\|NBSL, RESC1,
136	"", },
137
138	/* long -> double */
139	{ SCONV, INCREG,
140	SBREG\|SNAME\|SOREG\|SCON, TLONG,
141	SANY, TFLOAT\|TDOUBLE,
142	NCREG\|NCSL, RESC1,
143	"mov UL,-(sp)\nmov AL,-(sp)\n"
144	"setl\nmovif (sp)+,A1\nseti\n", },
145
146	/*
147	* Subroutine calls.
148	*/
149	{ CALL, INBREG,
150	SCON, TANY,
151	SBREG, TLONG\|TULONG,
152	NBREG\|NBSL, RESC1,
153	"jsr pc,*CL\nZC", },
154
155	{ UCALL, INBREG,
156	SCON, TANY,
157	SBREG, TLONG\|TULONG,
158	NBREG\|NBSL, RESC1,
159	"jsr pc,*CL\n", },
160
161	{ CALL, FOREFF,
162	SCON\|SNAME\|SOREG, TANY,
163	SANY, TANY,
164	0, 0,
165	"jsr pc,*AL\nZC", },
166
167	{ UCALL, FOREFF,
168	SCON\|SNAME\|SOREG, TANY,
169	SANY, TANY,
170	0, 0,
171	"jsr pc,*AL\n", },
172
173	{ CALL, INAREG,
174	SCON\|SOREG\|SNAME, TANY,
175	SAREG, TWORD\|TPOINT\|TCHAR\|TUCHAR,
176	NAREG\|NASL, RESC1,
177	"jsr pc,*AL\nZC", },
178
179	{ UCALL, INAREG,
180	SCON\|SOREG\|SNAME, TANY,
181	SAREG, TWORD\|TPOINT\|TCHAR\|TUCHAR,
182	NAREG\|NASL, RESC1,
183	"jsr pc,*AL\n", },
184
185	{ CALL, FOREFF,
186	SAREG, TANY,
187	SANY, TANY,
188	0, 0,
189	"jsr pc,(AL)\nZC", },
190
191	{ UCALL, FOREFF,
192	SAREG, TANY,
193	SANY, TANY,
194	0, 0,
195	"jsr pc,(AL)\n", },
196
197	{ CALL, INAREG,
198	SAREG, TANY,
199	SANY, TANY,
200	NAREG\|NASL, RESC1, /* should be 0 */
201	"jsr pc,(AL)\nZC", },
202
203	{ UCALL, INAREG,
204	SAREG, TANY,
205	SANY, TANY,
206	NAREG\|NASL, RESC1, /* should be 0 */
207	"jsr pc,(AL)\n", },
208
209	/*
210	* The next rules handle all binop-style operators.
211	*/
212	/* Add one to anything left but use only for side effects */
213	{ PLUS, FOREFF\|INAREG\|FORCC,
214	SAREG\|SNAME\|SOREG, TWORD\|TPOINT,
215	SONE, TANY,
216	0, RLEFT\|RESCC,
217	"inc AL\n", },
218
219	/* add one for char to reg, special handling */
220	{ PLUS, FOREFF\|INAREG\|FORCC,
221	SAREG, TCHAR\|TUCHAR,
222	SONE, TANY,
223	0, RLEFT\|RESCC,
224	"inc AL\n", },
225
226	/* add one for char to memory */
227	{ PLUS, FOREFF\|FORCC,
228	SNAME\|SOREG\|STARNM, TCHAR\|TUCHAR,
229	SONE, TANY,
230	0, RLEFT\|RESCC,
231	"incb AL\n", },
232
233	{ PLUS, INBREG\|FOREFF,
234	SBREG, TLONG,
235	SBREG\|SNAME\|SOREG\|SCON, TLONG,
236	0, RLEFT,
237	"add AR,AL\nadd UR,UL\nadc AL\n", },
238
239	/* Add to reg left and reclaim reg */
240	{ PLUS, INAREG\|FOREFF\|FORCC,
241	SAREG\|SNAME\|SOREG, TWORD\|TPOINT,
242	SAREG\|SNAME\|SOREG\|SCON, TWORD\|TPOINT,
243	0, RLEFT\|RESCC,
244	"add AR,AL\n", },
245
246	/* Add to anything left but use only for side effects */
247	{ PLUS, FOREFF\|FORCC,
248	SNAME\|SOREG, TWORD\|TPOINT,
249	SAREG\|SNAME\|SOREG\|SCON, TWORD\|TPOINT,
250	0, RLEFT\|RESCC,
251	"add AR,AL\n", },
252
253	{ PLUS, INAREG\|FOREFF\|FORCC,
254	SAREG, TCHAR\|TUCHAR,
255	SAREG\|SNAME\|SOREG\|SCON, TCHAR\|TUCHAR,
256	0, RLEFT\|RESCC,
257	"add AR,AL\n", },
258
259	/* Post-increment read, byte */
260	{ MINUS, INAREG,
261	SINCB, TCHAR\|TUCHAR,
262	SONE, TANY,
263	NAREG, RESC1,
264	"movb ZG,A1\nincb ZG\n", },
265
266	/* Post-increment read, int */
267	{ MINUS, INAREG,
268	SINCB, TWORD\|TPOINT,
269	SONE, TANY,
270	NAREG, RESC1,
271	"mov ZG,A1\ninc ZG\n", },
272
273	{ MINUS, INBREG\|FOREFF,
274	SBREG, TLONG\|TULONG,
275	SBREG\|SNAME\|SOREG\|SCON, TLONG\|TULONG,
276	0, RLEFT,
277	"sub AR,AL\nsub UR,UL\nsbc AL\n", },
278
279	/* Sub one from anything left */
280	{ MINUS, FOREFF\|INAREG\|FORCC,
281	SAREG\|SNAME\|SOREG, TWORD\|TPOINT,
282	SONE, TANY,
283	0, RLEFT\|RESCC,
284	"dec AL\n", },
285
286	{ MINUS, INAREG\|FOREFF,
287	SAREG, TWORD\|TPOINT,
288	SAREG\|SNAME\|SOREG\|SCON, TWORD\|TPOINT,
289	0, RLEFT,
290	"sub AR,AL\n", },
291
292	/* Sub from anything left but use only for side effects */
293	{ MINUS, FOREFF\|INAREG\|FORCC,
294	SAREG\|SNAME\|SOREG, TWORD\|TPOINT,
295	SAREG\|SNAME\|SOREG\|SCON, TWORD\|TPOINT,
296	0, RLEFT\|RESCC,
297	"sub AR,AL\n", },
298
299	/* Sub one left but use only for side effects */
300	{ MINUS, FOREFF\|FORCC,
301	SAREG\|SNAME\|SOREG, TCHAR\|TUCHAR,
302	SONE, TANY,
303	0, RLEFT\|RESCC,
304	"decb AL\n", },
305
306	/* Sub from anything left but use only for side effects */
307	{ MINUS, FOREFF\|FORCC,
308	SAREG\|SNAME\|SOREG, TCHAR\|TUCHAR,
309	SAREG\|SNAME\|SOREG\|SCON, TCHAR\|TUCHAR\|TWORD\|TPOINT,
310	0, RLEFT\|RESCC,
311	"subb AR,AL\n", },
312
313	/*
314	* The next rules handle all shift operators.
315	*/
316	{ LS, INBREG\|FOREFF,
317	SBREG, TLONG\|TULONG,
318	SANY, TANY,
319	0, RLEFT,
320	"ashc AR,AL\n", },
321
322	{ LS, INAREG\|FOREFF,
323	SAREG, TWORD,
324	SONE, TANY,
325	0, RLEFT,
326	"asl AL\n", },
327
328	{ LS, INAREG\|FOREFF,
329	SAREG, TWORD,
330	ANYSH, TWORD,
331	0, RLEFT,
332	"ash AR,AL\n", },
333
334	/*
335	* The next rules takes care of assignments. "=".
336	*/
337
338	/* First optimizations, in lack of weight it uses first found */
339	/* Start with class A registers */
340
341	/* Clear word at address */
342	{ ASSIGN, FOREFF\|FORCC,
343	ARONS, TWORD\|TPOINT,
344	SZERO, TANY,
345	0, RESCC,
346	"clr AL\n", },
347
348	/* Clear word at reg */
349	{ ASSIGN, FOREFF\|INAREG,
350	SAREG, TWORD\|TPOINT,
351	SZERO, TANY,
352	0, RDEST,
353	"clr AL\n", },
354
355	/* Clear byte at address. No reg here. */
356	{ ASSIGN, FOREFF,
357	SNAME\|SOREG\|STARNM, TCHAR\|TUCHAR,
358	SZERO, TANY,
359	0, RDEST,
360	"clrb AL\n", },
361
362	/* Clear byte in reg. must clear the whole register. */
363	{ ASSIGN, FOREFF\|INAREG,
364	SAREG, TCHAR\|TUCHAR,
365	SZERO, TANY,
366	0, RDEST,
367	"clr AL\n", },
368
369	/* The next is class B regs */
370
371	/* Clear long at address or in reg */
372	{ ASSIGN, FOREFF\|INBREG,
373	SNAME\|SOREG\|SBREG, TLONG\|TULONG,
374	SZERO, TANY,
375	0, RDEST,
376	"clr AL\nclr UL\n", },
377
378	/* Save 2 bytes if high-order bits are zero */
379	{ ASSIGN, FOREFF\|INBREG,
380	SBREG, TLONG\|TULONG,
381	SSCON, TLONG,
382	0, RDEST,
383	"mov UR,UL\nsxt AL\n", },
384
385	/* Must have multiple rules for long otherwise regs may be trashed */
386	{ ASSIGN, FOREFF\|INBREG,
387	SBREG, TLONG\|TULONG,
388	SCON\|SNAME\|SOREG, TLONG\|TULONG,
389	0, RDEST,
390	"mov AR,AL\nmov UR,UL\n", },
391
392	{ ASSIGN, FOREFF\|INBREG,
393	SNAME\|SOREG, TLONG\|TULONG,
394	SBREG, TLONG\|TULONG,
395	0, RDEST,
396	"mov AR,AL\nmov UR,UL\n", },
397
398	{ ASSIGN, FOREFF,
399	SNAME\|SOREG, TLONG\|TULONG,
400	SCON\|SNAME\|SOREG, TLONG\|TULONG,
401	0, 0,
402	"mov AR,AL\nmov UR,UL\n", },
403
404	{ ASSIGN, INBREG\|FOREFF,
405	SBREG, TLONG\|TULONG,
406	SBREG, TLONG\|TULONG,
407	0, RDEST,
408	"ZE\n", },
409
410	{ ASSIGN, FOREFF\|INAREG\|FORCC,
411	SAREG, TWORD\|TPOINT,
412	SAREG\|SNAME\|SOREG\|SCON, TWORD\|TPOINT,
413	0, RDEST\|RESCC,
414	"mov AR,AL\n", },
415
416	{ ASSIGN, FOREFF\|INAREG\|FORCC,
417	ARONS, TWORD\|TPOINT,
418	SAREG, TWORD\|TPOINT,
419	0, RDEST\|RESCC,
420	"mov AR,AL\n", },
421
422	{ ASSIGN, FOREFF\|FORCC,
423	SNAME\|SOREG, TWORD\|TPOINT,
424	SNAME\|SOREG\|SCON, TWORD\|TPOINT,
425	0, RESCC,
426	"mov AR,AL\n", },
427
428	{ ASSIGN, FOREFF\|INAREG\|FORCC,
429	SAREG, TCHAR\|TUCHAR,
430	ARONS\|SCON, TCHAR\|TUCHAR,
431	0, RDEST\|RESCC,
432	"movb AR,AL\n", },
433
434	{ ASSIGN, FOREFF\|INAREG\|FORCC,
435	ARONS, TCHAR\|TUCHAR,
436	SAREG, TCHAR\|TUCHAR,
437	0, RDEST\|RESCC,
438	"movb AR,AL\n", },
439
440	{ ASSIGN, FOREFF\|FORCC,
441	SNAME\|SOREG\|STARNM, TCHAR\|TUCHAR,
442	SNAME\|SOREG\|SCON\|STARNM, TCHAR\|TUCHAR,
443	0, RDEST\|RESCC,
444	"movb AR,AL\n", },
445
446	{ ASSIGN, FOREFF\|INCREG,
447	SCREG, TDOUBLE,
448	SNAME\|SOREG\|SCON, TDOUBLE,
449	0, RDEST,
450	"movf AR,AL\n", },
451
452	{ ASSIGN, FOREFF\|INCREG,
453	SCREG, TFLOAT,
454	SNAME\|SOREG\|SCON, TFLOAT,
455	0, RDEST,
456	"movof AR,AL\n", },
457
458	{ ASSIGN, FOREFF\|INCREG,
459	SNAME\|SOREG\|SCREG, TDOUBLE,
460	SCREG, TDOUBLE,
461	0, RDEST,
462	"movf AR,AL\n", },
463
464	{ ASSIGN, FOREFF\|INCREG,
465	SNAME\|SOREG\|SCREG, TFLOAT,
466	SCREG, TFLOAT,
467	0, RDEST,
468	"movfo AR,AL\n", },
469
470	/*
471	* DIV/MOD/MUL
472	*/
473	/* XXX - mul may use any odd register, only r1 for now */
474	{ MUL, INAREG,
475	SAREG, TWORD\|TPOINT,
476	SAREG\|SNAME\|SOREG\|SCON, TWORD\|TPOINT,
477	NSPECIAL, RLEFT,
478	"mul AR,AL\n", },
479
480	{ MUL, INBREG,
481	SBREG\|SNAME\|SCON\|SOREG, TLONG\|TULONG,
482	SBREG\|SNAME\|SCON\|SOREG, TLONG\|TULONG,
483	NSPECIAL\|NBREG\|NBSL\|NBSR, RESC1,
484	"mov UR,-(sp)\nmov AR,-(sp)\n"
485	"mov UL,-(sp)\nmov AL,-(sp)\n"
486	"jsr pc,lmul\nadd $10,sp\n", },
487
488	{ MUL, INCREG,
489	SCREG, TFLOAT\|TDOUBLE,
490	SCREG\|SNAME\|SOREG, TFLOAT\|TDOUBLE,
491	0, RLEFT,
492	"mulf AR,AL\n", },
493
494	/* need extra move to be sure N flag is correct for sxt */
495	{ DIV, INAREG,
496	ANYSH, TINT\|TPOINT,
497	ANYSH, TINT\|TPOINT,
498	NSPECIAL, RDEST,
499	"mov AL,r1\nsxt r0\ndiv AR,r0\n", },
500
501	/* udiv uses args in registers */
502	{ DIV, INAREG,
503	SAREG, TUNSIGNED,
504	SAREG, TUNSIGNED,
505	NSPECIAL\|NAREG\|NASL\|NASR, RESC1,
506	"jsr pc,udiv\n", },
507
508	{ DIV, INBREG,
509	SBREG\|SNAME\|SCON\|SOREG, TLONG\|TULONG,
510	SBREG\|SNAME\|SCON\|SOREG, TLONG\|TULONG,
511	NSPECIAL\|NBREG\|NBSL\|NBSR, RESC1,
512	"mov UR,-(sp)\nmov AR,-(sp)\n"
513	"mov UL,-(sp)\nmov AL,-(sp)\n"
514	"jsr pc,ldiv\nadd $10,sp\n", },
515
516	{ DIV, INCREG,
517	SCREG, TFLOAT\|TDOUBLE,
518	SCREG\|SNAME\|SOREG, TFLOAT\|TDOUBLE,
519	0, RLEFT,
520	"divf AR,AL\n", },
521
522	/* XXX merge the two below to one */
523	{ MOD, INBREG,
524	SBREG\|SNAME\|SCON\|SOREG, TLONG,
525	SBREG\|SNAME\|SCON\|SOREG, TLONG,
526	NSPECIAL\|NBREG\|NBSL\|NBSR, RESC1,
527	"mov UR,-(sp)\nmov AR,-(sp)\n"
528	"mov UL,-(sp)\nmov AL,-(sp)\n"
529	"jsr pc,lrem\nadd $10,sp\n", },
530
531	{ MOD, INBREG,
532	SBREG\|SNAME\|SCON\|SOREG, TULONG,
533	SBREG\|SNAME\|SCON\|SOREG, TULONG,
534	NSPECIAL\|NBREG\|NBSL\|NBSR, RESC1,
535	"mov UR,-(sp)\nmov AR,-(sp)\n"
536	"mov UL,-(sp)\nmov AL,-(sp)\n"
537	"jsr pc,ulrem\nadd $10,sp\n", },
538
539	/* urem uses args in registers */
540	{ MOD, INAREG,
541	SAREG, TUNSIGNED,
542	SAREG, TUNSIGNED,
543	NSPECIAL\|NAREG\|NASL\|NASR, RESC1,
544	"jsr pc,urem\n", },
545
546	/*
547	* Indirection operators.
548	*/
549	{ UMUL, INBREG,
550	SANY, TPOINT\|TWORD,
551	SOREG, TLONG\|TULONG,
552	NBREG, RESC1, /* \|NBSL - may overwrite index reg */
553	"mov AR,A1\nmov UR,U1\n", },
554
555	{ UMUL, INAREG,
556	SANY, TPOINT\|TWORD,
557	SOREG, TPOINT\|TWORD,
558	NAREG\|NASL, RESC1,
559	"mov AR,A1\n", },
560
561	{ UMUL, INAREG,
562	SANY, TANY,
563	SOREG, TCHAR\|TUCHAR,
564	NAREG\|NASL, RESC1,
565	"movb AR,A1\n", },
566
567	/*
568	* Logical/branching operators
569	*/
570	{ OPLOG, FORCC,
571	SAREG\|SOREG\|SNAME\|SCON, TWORD\|TPOINT,
572	SZERO, TANY,
573	0, RESCC,
574	"tst AL\n", },
575
576	{ OPLOG, FORCC,
577	SAREG\|SOREG\|SNAME\|SCON, TCHAR\|TUCHAR,
578	SZERO, TANY,
579	0, RESCC,
580	"tstb AL\n", },
581
582	{ OPLOG, FORCC,
583	SAREG\|SOREG\|SNAME\|SCON, TWORD\|TPOINT,
584	SAREG\|SOREG\|SNAME\|SCON, TWORD\|TPOINT,
585	0, RESCC,
586	"cmp AL,AR\n", },
587
588	{ OPLOG, FORCC,
589	SAREG\|SOREG\|SNAME\|SCON, TCHAR\|TUCHAR,
590	SAREG\|SOREG\|SNAME\|SCON, TCHAR\|TUCHAR,
591	0, RESCC,
592	"cmpb AL,AR\n", },
593
594	{ OPLOG, FORCC,
595	SBREG\|SOREG\|SNAME\|SCON, TLONG\|TULONG,
596	SZERO, TANY,
597	0, RNULL,
598	"ZD", },
599
600	{ OPLOG, FORCC,
601	SBREG\|SOREG\|SNAME, TLONG\|TULONG,
602	SBREG\|SOREG\|SNAME, TLONG\|TULONG,
603	0, RNULL,
604	"ZF", },
605
606	/* AND/OR/ER/NOT */
607	/* Optimize if high order bits are zero */
608	{ AND, FOREFF\|INBREG\|FORCC,
609	SOREG\|SNAME\|SBREG, TLONG\|TULONG,
610	SANDSCON, TLONG\|TULONG,
611	0, RLEFT\|RESCC,
612	"clr AL\nbic UR,UL\n", },
613
614	{ AND, INBREG\|FORCC,
615	SBREG, TLONG\|TULONG,
616	SCON\|SBREG\|SOREG\|SNAME, TLONG\|TULONG,
617	0, RLEFT\|RESCC,
618	"bic AR,AL\nbic UR,UL\n", },
619
620	/* set status bits */
621	{ AND, FORCC,
622	ARONS\|SCON, TWORD\|TPOINT,
623	ARONS\|SCON, TWORD\|TPOINT,
624	0, RESCC,
625	"bit AR,AL\n", },
626
627	/* AND with int */
628	{ AND, INAREG\|FORCC\|FOREFF,
629	SAREG\|SNAME\|SOREG, TWORD,
630	SCON\|SAREG\|SOREG\|SNAME, TWORD,
631	0, RLEFT\|RESCC,
632	"bic AR,AL\n", },
633
634	/* AND with char */
635	{ AND, INAREG\|FORCC,
636	SAREG\|SOREG\|SNAME, TCHAR\|TUCHAR,
637	ARONS\|SCON, TCHAR\|TUCHAR,
638	0, RLEFT\|RESCC,
639	"bicb AR,AL\n", },
640
641	{ OR, INBREG\|FORCC,
642	SBREG, TLONG\|TULONG,
643	SCON\|SBREG\|SOREG\|SNAME, TLONG\|TULONG,
644	0, RLEFT\|RESCC,
645	"bis AR,AL\nbis UR,UL\n", },
646
647	/* OR with int */
648	{ OR, FOREFF\|INAREG\|FORCC,
649	ARONS, TWORD,
650	ARONS\|SCON, TWORD,
651	0, RLEFT\|RESCC,
652	"bis AR,AL\n", },
653
654	/* OR with char */
655	{ OR, INAREG\|FORCC,
656	SAREG\|SOREG\|SNAME, TCHAR\|TUCHAR,
657	ARONS\|SCON, TCHAR\|TUCHAR,
658	0, RLEFT\|RESCC,
659	"bisb AR,AL\n", },
660
661	/* XOR with int (extended insn) */
662	{ ER, INAREG\|FORCC,
663	ARONS, TWORD,
664	SAREG, TWORD,
665	0, RLEFT\|RESCC,
666	"xor AR,AL\n", },
667
668	/* XOR with char (extended insn) */
669	{ ER, INAREG\|FORCC,
670	SAREG, TCHAR\|TUCHAR,
671	SAREG, TCHAR\|TUCHAR,
672	0, RLEFT\|RESCC,
673	"xor AR,AL\n", },
674
675	/*
676	* Jumps.
677	*/
678	{ GOTO, FOREFF,
679	SCON, TANY,
680	SANY, TANY,
681	0, RNOP,
682	"jbr LL\n", },
683
684	/*
685	* Convert LTYPE to reg.
686	*/
687	/* Two bytes less if high half of constant is zero */
688	{ OPLTYPE, INBREG,
689	SANY, TANY,
690	SSCON, TLONG\|TULONG,
691	NBREG, RESC1,
692	"mov UL,U1\nsxt A1\n", },
693
694	/* XXX - avoid OREG index register to be overwritten */
695	{ OPLTYPE, INBREG,
696	SANY, TANY,
697	SCON\|SBREG\|SNAME\|SOREG, TLONG\|TULONG,
698	NBREG, RESC1,
699	"mov AL,A1\nmov UL,U1\n", },
700
701	{ OPLTYPE, INAREG,
702	SANY, TANY,
703	SAREG\|SCON\|SOREG\|SNAME, TWORD\|TPOINT,
704	NAREG\|NASR, RESC1,
705	"mov AL,A1\n", },
706
707	{ OPLTYPE, INAREG,
708	SANY, TANY,
709	SAREG\|SCON\|SOREG\|SNAME, TCHAR,
710	NAREG, RESC1,
711	"movb AR,A1\n", },
712
713	{ OPLTYPE, INAREG,
714	SANY, TANY,
715	SAREG\|SCON\|SOREG\|SNAME, TUCHAR,
716	NAREG, RESC1,
717	"clr A1\nbisb AL,A1\n", },
718
719	{ OPLTYPE, INCREG,
720	SANY, TANY,
721	SCREG\|SCON\|SOREG\|SNAME, TDOUBLE,
722	NCREG, RESC1,
723	"movf AL,A1\n", },
724
725	{ OPLTYPE, INCREG,
726	SANY, TANY,
727	SCREG\|SCON\|SOREG\|SNAME, TFLOAT,
728	NCREG, RESC1,
729	"movof AL,A1\n", },
730
731	/*
732	* Negate a word.
733	*/
734	{ UMINUS, INAREG\|FOREFF,
735	SAREG, TWORD\|TPOINT\|TCHAR\|TUCHAR,
736	SANY, TANY,
737	0, RLEFT,
738	"neg AL\n", },
739
740	{ UMINUS, INBREG\|FOREFF,
741	SBREG\|SOREG\|SNAME, TLONG,
742	SANY, TANY,
743	0, RLEFT,
744	"neg AL\nneg UL\nsbc AL\n", },
745
746
747	{ COMPL, INBREG,
748	SBREG, TLONG\|TULONG,
749	SANY, TANY,
750	0, RLEFT,
751	"com AL\ncom UL\n", },
752
753	{ COMPL, INAREG,
754	SAREG, TWORD,
755	SANY, TANY,
756	0, RLEFT,
757	"com AL\n", },
758
759	/*
760	* Arguments to functions.
761	*/
762	{ FUNARG, FOREFF,
763	SCON\|SBREG\|SNAME\|SOREG, TLONG\|TULONG,
764	SANY, TLONG\|TULONG,
765	0, RNULL,
766	"mov UL,ZA(sp)\nmov AL,-(sp)\n", },
767
768	{ FUNARG, FOREFF,
769	SZERO, TANY,
770	SANY, TANY,
771	0, RNULL,
772	"clr ZA(sp)\n", },
773
774	{ FUNARG, FOREFF,
775	SARGSUB, TWORD\|TPOINT,
776	SANY, TWORD\|TPOINT,
777	0, RNULL,
778	"ZB", },
779
780	{ FUNARG, FOREFF,
781	SARGINC, TWORD\|TPOINT,
782	SANY, TWORD\|TPOINT,
783	0, RNULL,
784	"ZH", },
785
786	{ FUNARG, FOREFF,
787	SCON\|SAREG\|SNAME\|SOREG, TWORD\|TPOINT,
788	SANY, TWORD\|TPOINT,
789	0, RNULL,
790	"mov AL,ZA(sp)\n", },
791
792	{ FUNARG, FOREFF,
793	SCON, TCHAR\|TUCHAR,
794	SANY, TANY,
795	0, RNULL,
796	"mov AL,ZA(sp)\n", },
797
798	{ FUNARG, FOREFF,
799	SNAME\|SOREG, TCHAR,
800	SANY, TCHAR,
801	NAREG, RNULL,
802	"movb AL,A1\nmov A1,ZA(sp)\n", },
803
804	{ FUNARG, FOREFF,
805	SNAME\|SOREG, TUCHAR,
806	SANY, TUCHAR,
807	NAREG, RNULL,
808	"clr ZA(sp)\nbisb AL,(sp)\n", },
809
810	{ FUNARG, FOREFF,
811	SAREG, TUCHAR\|TCHAR,
812	SANY, TUCHAR\|TCHAR,
813	0, RNULL,
814	"mov AL,ZA(sp)\n", },
815
816	{ FUNARG, FOREFF,
817	SCREG, TFLOAT\|TDOUBLE,
818	SANY, TANY,
819	0, RNULL,
820	"movf AL,ZA(sp)\n", },
821
822	# define DF(x) FORREW,SANY,TANY,SANY,TANY,REWRITE,x,""
823
824	{ UMUL, DF( UMUL ), },
825
826	{ ASSIGN, DF(ASSIGN), },
827
828	{ STASG, DF(STASG), },
829
830	{ FLD, DF(FLD), },
831
832	{ OPLEAF, DF(NAME), },
833
834	/* { INIT, DF(INIT), }, */
835
836	{ OPUNARY, DF(UMINUS), },
837
838	{ OPANY, DF(BITYPE), },
839
840	{ FREE, FREE, FREE, FREE, FREE, FREE, FREE, FREE, "help; I'm in trouble\n" },
841	};
842
843	int tablesize = sizeof(table)/sizeof(table[0]);

Note: See TracBrowser for help on using the repository browser.

Download in other formats: