source: mainline/uspace/app/pcc/arch/pdp10/table.c@ 5974661

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 5974661 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: 24.5 KB
RevLine 
[a7de7182]1/* $Id: table.c,v 1.97 2008/02/10 19:25:44 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|TULONG
37# define TSWORD TINT|TLONG
38# define TWORD TUWORD|TSWORD
39
40struct optab table[] = {
41{ -1, FORREW,SANY,TANY,SANY,TANY,REWRITE,-1,"", },
42/*
43 * A bunch of pointer conversions.
44 * First pointer to integer.
45 */
46/* Convert char pointer to int */
47{ SCONV, INAREG,
48 SAREG|SAREG, TPTRTO|TCHAR|TUCHAR,
49 SANY, TWORD,
50 NAREG, RLEFT,
51 " lsh AL,2\n"
52 " move A1,AL\n"
53 " lsh A1,-040\n"
54 " trz A1,074\n"
55 " ior AL,A1\n"
56 " tlz AL,0740000\n", },
57
58/* Convert short pointer to int */
59{ SCONV, INAREG,
60 SAREG|SAREG, TPTRTO|TSHORT|TUSHORT,
61 SANY, TWORD,
62 NAREG, RLEFT,
63 " lsh AL,2\n"
64 " move A1,AL\n"
65 " lsh A1,-041\n"
66 " trz A1,2\n"
67 " ior AL,A1\n"
68 " tlz AL,0740000\n", },
69
70/* Convert int/unsigned/long/ulong/struct/union/func ptr to int */
71{ SCONV, INAREG,
72 SAREG|SAREG, TPTRTO|TWORD|TSTRUCT|TPOINT,
73 SANY, TWORD,
74 0, RLEFT,
75 " lsh AL,2\n", },
76
77/*
78 * Convert int/long to pointers.
79 */
80/* Convert int to char pointer */
81{ PCONV, INAREG,
82 SAREG, TWORD,
83 SANY, TPTRTO|TCHAR|TUCHAR,
84 NAREG, RLEFT,
85 " move A1,AL\n"
86 " lsh A1,036\n"
87 " tlo A1,0700000\n"
88 " tlz A1,0040000\n"
89 " lsh AL,-2\n"
90 " ior AL,A1\n", },
91
92/* Convert int/long to short pointer */
93{ PCONV, INAREG,
94 SAREG, TWORD,
95 SANY, TPTRTO|TSHORT|TUSHORT,
96 NAREG, RLEFT,
97 " move A1,AL\n"
98 " lsh AL,-2\n"
99 " tlo AL,0750000\n"
100 " lsh A1,035\n"
101 " tlz A1,0760000\n"
102 " add AL,A1\n", },
103
104/* Convert int/long to int/struct/multiple ptr */
105{ PCONV, INAREG,
106 SAREG, TWORD,
107 SANY, TPOINT|TWORD|TSTRUCT,
108 0, RLEFT,
109 " lsh AL,-2\n", },
110
111/*
112 * Pointer to pointer conversions.
113 */
114/* Convert char ptr to short ptr */
115{ PCONV, INAREG,
116 SAREG, TPTRTO|TCHAR|TUCHAR,
117 SANY, TPTRTO|TSHORT|TUSHORT,
118 0, RLEFT,
119 " tlo AL,050000\n"
120 " tlne AL,020000\n"
121 " tlz AL,010000\n", },
122
123/* Convert char/short pointer to int/struct/multiple ptr */
124{ PCONV, INAREG,
125 SAREG, TPTRTO|TCHAR|TUCHAR|TSHORT|TUSHORT,
126 SANY, TPOINT|TWORD|TSTRUCT,
127 0, RLEFT,
128 " tlz AL,0770000\n", },
129
130/* Convert short pointer to char ptr */
131{ PCONV, INAREG,
132 SAREG, TPTRTO|TSHORT|TUSHORT,
133 SANY, TPTRTO|TCHAR|TUCHAR,
134 0, RLEFT,
135 " tlz AL,050000\n", },
136
137/* Convert int/struct/foo pointer to char ptr */
138{ PCONV, INAREG,
139 SAREG, TPOINT|TWORD|TSTRUCT,
140 SANY, TPTRTO|TCHAR|TUCHAR,
141 0, RLEFT,
142 " tlo AL,0700000\n", },
143
144/* Convert int/struct/foo pointer to short ptr */
145{ PCONV, INAREG,
146 SAREG, TPTRTO|TWORD|TSTRUCT,
147 SANY, TPTRTO|TSHORT|TUSHORT,
148 0, RLEFT,
149 " tlo AL,0750000\n", },
150
151/*
152 * A bunch conversions of integral<->integral types
153 */
154
155/* convert short/char to int. This is done when register is loaded */
156{ SCONV, INAREG,
157 SAREG, TSHORT|TUSHORT|TCHAR|TUCHAR|TWORD,
158 SANY, TWORD,
159 0, RLEFT,
160 "", },
161
162/* convert int to short/char. This is done when register is loaded */
163{ SCONV, INAREG,
164 SAREG, TWORD,
165 SANY, TSHORT|TUSHORT|TCHAR|TUCHAR|TWORD,
166 0, RLEFT,
167 "", },
168
169/* convert int/long to unsigned long long */
170{ SCONV, INAREG,
171 SAREG|SAREG|SNAME|SOREG, TWORD,
172 SANY, TULONGLONG,
173 NAREG|NASL, RESC1,
174 " move U1,AL\n"
175 " setz A1,\n"
176 " tlze U1,0400000\n"
177 " tro A1,01\n" , },
178
179/* convert int/long to long long */
180{ SCONV, INAREG,
181 SAREG|SAREG|SNAME|SOREG, TWORD,
182 SANY, TLONGLONG,
183 NAREG|NASL, RESC1,
184 " move U1,AL\n"
185 " move A1,U1\n"
186 " ash A1,-043\n", },
187
188/* convert uchar/ushort to (unsigned) long long */
189{ SCONV, INAREG,
190 SAREG|SAREG|SNAME|SOREG, TUCHAR|TUSHORT,
191 SANY, TLL,
192 NAREG|NASL, RESC1,
193 " move U1,AL\n"
194 " setz A1,\n", },
195
196/* convert long long to int/long */
197{ SCONV, INAREG,
198 SAREG|SAREG|SNAME|SOREG, TLL,
199 SANY, TWORD,
200 NAREG|NASL, RESC1,
201 " move A1,UL\n", },
202
203/* convert long long to unsigned char - XXX - signed char */
204{ SCONV, INAREG,
205 SAREG|SAREG|SNAME|SOREG, TLL,
206 SANY, TCHAR|TUCHAR,
207 NAREG|NASL, RESC1,
208 " move A1,UL\n"
209 " andi A1,0777\n", },
210
211/* convert long long to short - XXX - signed short */
212{ SCONV, INAREG,
213 SAREG|SAREG|SNAME|SOREG, TLL,
214 SANY, TSHORT|TUSHORT,
215 NAREG|NASL, RESC1,
216 " move A1,UL\n"
217 " hrrz A1,A1\n", },
218
219/* floating point conversions */
220{ SCONV, INAREG,
221 SAREG|SAREG|SNAME|SOREG, TDOUBLE|TFLOAT,
222 SANY, TWORD,
223 NAREG|NASL, RESC1,
224 " fix A1,AL\n", },
225
226{ SCONV, INAREG,
227 SAREG|SAREG|SNAME|SOREG, TWORD,
228 SANY, TFLOAT,
229 NAREG|NASL, RESC1,
230 " fltr A1,AL\n", },
231
232{ SCONV, INAREG,
233 SAREG|SAREG|SNAME|SOREG, TWORD,
234 SANY, TDOUBLE,
235 NAREG|NASL, RESC1,
236 " fltr A1,AL\n setz U1,\n", },
237
238{ SCONV, INAREG,
239 SAREG|SAREG|SNAME|SOREG, TDOUBLE,
240 SANY, TFLOAT,
241 NAREG|NASL, RESC1,
242 " move A1,AL\n", },
243
244{ SCONV, INAREG,
245 SAREG|SAREG|SNAME|SOREG, TFLOAT,
246 SANY, TDOUBLE,
247 NAREG|NASL, RESC1,
248 " move A1,AL\n setz U1,\n", },
249
250/*
251 * Subroutine calls.
252 */
253
254{ UCALL, FOREFF,
255 SCON, TANY,
256 SANY, TANY,
257 0, 0, /* should be 0 */
258 " pushj 017,AL\nZB", },
259
260{ CALL, FOREFF,
261 SCON, TANY,
262 SANY, TANY,
263 0, 0, /* should be 0 */
264 " pushj 017,AL\nZB", },
265
266{ UCALL, INAREG,
267 SCON, TANY,
268 SANY, TWORD|TCHAR|TUCHAR|TSHORT|TUSHORT|TFLOAT|TPOINT,
269 NAREG, RESC1, /* should be 0 */
270 " pushj 017,AL\nZB", },
271
272{ CALL, INAREG,
273 SCON, TANY,
274 SANY, TANY,
275 NAREG|NASL, RESC1, /* should be 0 */
276 " pushj 017,AL\nZB", },
277
278{ UCALL, INAREG,
279 SAREG|SAREG, TANY,
280 SANY, TWORD|TCHAR|TUCHAR|TSHORT|TUSHORT|TFLOAT|TDOUBLE|TLL|TPOINT,
281 NAREG|NASL, RESC1, /* should be 0 */
282 " pushj 017,(AL)\nZB", },
283
284{ UCALL, INAREG,
285 SNAME|SOREG, TANY,
286 SANY, TWORD|TCHAR|TUCHAR|TSHORT|TUSHORT|TFLOAT|TDOUBLE|TLL|TPOINT,
287 NAREG, RESC1, /* should be 0 */
288 " pushj 017,@AL\nZB", },
289
290#ifdef notyet
291/*
292 * INCR can be slightly optimized.
293 */
294{ INCR, INAREG,
295 SAREG|SAREG|SNAME|SOREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TPTRTO,
296 SONE, TANY,
297 NAREG, RESC1,
298 " move A1,AL\n"
299 " ibp AL\n", },
300
301/* Fix check of return value */
302{ INCR, FOREFF,
303 SAREG|SAREG|SNAME|SOREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TPTRTO,
304 SONE, TANY,
305 0, 0,
306 " ibp AL\n", },
307#endif
308
309/*
310 * PLUS operators.
311 */
312/* Add a value to a char/short pointer */
313{ PLUS, INAREG|INAREG|FOREFF,
314 SAREG|SAREG|SNAME|SOREG, TPTRTO|TCHAR|TUCHAR|TSHORT|TUSHORT,
315 SAREG|SAREG, TWORD,
316 0, RRIGHT,
317 " adjbp AR,AL\n", },
318
319/* No more search for char/short pointer addition */
320{ PLUS, INAREG|INAREG|FOREFF,
321 SANY, TPTRTO|TCHAR|TUCHAR|TSHORT|TUSHORT,
322 SANY, TANY,
323 REWRITE, 0,
324 "DIEDIEDIE!\n", },
325
326/* Add char/short/int to register */
327{ PLUS, FOREFF|INAREG|INAREG,
328 SAREG|SAREG, TWORD,
329 SAREG|SAREG|SNAME|SOREG, TWORD,
330 0, RLEFT,
331 " add AL,AR\n", },
332
333/* Add char/short/int to memory */
334{ PLUS, FOREFF|INAREG|INAREG,
335 SAREG|SAREG|SNAME|SOREG, TWORD,
336 SAREG|SAREG, TWORD,
337 0, RLEFT,
338 " addm AR,AL\n", },
339
340/* Add a small constant to a register */
341{ PLUS, FOREFF|INAREG|INAREG,
342 SAREG|SAREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD|TPOINT,
343 SUSHCON, TWORD,
344 0, RLEFT,
345 " addi AL,AR\n", },
346
347/* Add a larger constant to a register */
348{ PLUS, FOREFF|INAREG|INAREG,
349 SAREG|SAREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD|TPOINT,
350 SCON, TWORD,
351 0, RLEFT,
352 " add AL,[ .long AR ]\n", },
353
354/* Add long long to register */
355{ PLUS, INAREG|INAREG|FOREFF,
356 SAREG|SAREG, TLL,
357 SAREG|SAREG|SNAME|SOREG, TLL,
358 0, RLEFT,
359 " dadd AL,AR\n", },
360
361/* Add int (or int pointer) to register */
362{ PLUS, FOREFF|INAREG|INAREG,
363 SAREG|SAREG, TWORD|TPOINT,
364 SAREG|SAREG|SNAME|SOREG, TWORD,
365 0, RLEFT,
366 " add AL,AR # foo \n", },
367
368/* char/short are allowed to be added if they are in registers */
369{ PLUS, INAREG|INAREG|FOREFF,
370 SAREG|SAREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
371 SAREG|SAREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
372 0, RLEFT,
373 " add AL,AR\n", },
374
375/* get address of an memory position into a register */
376{ PLUS, INAREG|INAREG,
377 SAREG|SAREG, TWORD|TPTRTO,
378 SCON, TANY,
379 NAREG, RESC1,
380 " xmovei A1,AR(AL)\n", },
381
382/* Safety belt for plus */
383{ PLUS, FORREW|FOREFF|INAREG|INAREG,
384 SANY, TANY,
385 SANY, TANY,
386 REWRITE, 0,
387 "DIEDIEDIE", },
388
389/*
390 * MINUS operators.
391 */
392/* Rewrite subtracts from char/short pointers (to negative adds) */
393{ MINUS, FORREW|FOREFF|INAREG|INAREG,
394 SANY, TCHAR|TUCHAR|TSHORT|TUSHORT|TPTRTO,
395 SANY, TANY,
396 REWRITE, 0,
397 "DIEDIEDIE", },
398
399/* Subtract char/short/int word in memory from reg */
400{ MINUS, FOREFF|INAREG|INAREG,
401 SAREG|SAREG, TWORD|TPOINT,
402 SAREG|SAREG|SNAME|SOREG, TWORD|TPOINT,
403 0, RLEFT,
404 " sub AL,AR\n", },
405
406/* Subtract a small constant from reg */
407{ MINUS, FOREFF|INAREG|INAREG,
408 SAREG|SAREG, TWORD|TPOINT,
409 SUSHCON, TWORD|TPOINT,
410 0, RLEFT,
411 " subi AL,AR\n", },
412
413/* Subtract a large constant from reg */
414{ MINUS, FOREFF|INAREG|INAREG,
415 SAREG|SAREG, TWORD|TPOINT,
416 SCON, TWORD|TPOINT,
417 0, RLEFT,
418 " sub AL,[ .long AR ]\n", },
419
420/* Subtract char/short/int word in memory from reg, save in memory */
421{ MINUS, FOREFF|INAREG|INAREG,
422 SAREG|SAREG, TWORD,
423 SAREG|SAREG|SNAME|SOREG, TWORD,
424 0, RRIGHT,
425 " subm AL,AR\n", },
426
427/* Subtract long long from register */
428{ MINUS, INAREG|INAREG|FOREFF,
429 SAREG|SAREG, TLL,
430 SAREG|SAREG|SNAME|SOREG, TLL,
431 0, RLEFT,
432 " dsub AL,AR\n", },
433
434/* char/short are allowed to be subtracted if they are in registers */
435{ MINUS, INAREG|INAREG|FOREFF,
436 SAREG|SAREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
437 SAREG|SAREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
438 0, RLEFT,
439 " sub AL,AR\n", },
440
441/* Safety belt for plus */
442{ MINUS, FORREW|FOREFF|INAREG|INAREG,
443 SANY, TANY,
444 SANY, TANY,
445 REWRITE, 0,
446 "DIEDIEDIE", },
447
448/*
449 * AND/OR/ER operators.
450 * Simpler that the ops above in that they only work on integral types.
451 */
452/* And char/short/int with integer memory */
453{ AND, FOREFF|INAREG|INAREG,
454 SAREG|SAREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
455 SAREG|SAREG|SNAME|SOREG, TWORD,
456 0, RLEFT,
457 " and AL,AR\n", },
458
459/* And char/short/int with register */
460{ AND, FOREFF|INAREG|INAREG,
461 SAREG|SAREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
462 SAREG|SAREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
463 0, RLEFT,
464 " and AL,AR\n", },
465
466/* And char/short/int with small constant */
467{ AND, FOREFF|INAREG|INAREG,
468 SAREG|SAREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
469 SUSHCON, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
470 0, RLEFT,
471 " andi AL,AR\n", },
472
473/* And char/short/int with large constant */
474{ AND, FOREFF|INAREG|INAREG,
475 SAREG|SAREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
476 SCON, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
477 0, RLEFT,
478 " and AL,[ .long AR ]\n", },
479
480/* long long AND */
481{ AND, INAREG|FOREFF,
482 SAREG|SAREG, TLL,
483 SAREG|SAREG|SNAME|SOREG, TLL,
484 0, RLEFT,
485 " and AL,AR\n"
486 " and UL,UR\n", },
487
488/* Safety belt for AND */
489{ AND, FORREW|FOREFF|INAREG|INAREG,
490 SANY, TANY,
491 SANY, TANY,
492 REWRITE, 0,
493 "DIEDIEDIE", },
494
495
496/* OR char/short/int with integer memory */
497{ OR, FOREFF|INAREG|INAREG,
498 SAREG|SAREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
499 SAREG|SAREG|SNAME|SOREG, TWORD,
500 0, RLEFT,
501 " ior AL,AR\n", },
502
503/* OR char/short/int with register */
504{ OR, FOREFF|INAREG|INAREG,
505 SAREG|SAREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
506 SAREG|SAREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
507 0, RLEFT,
508 " ior AL,AR\n", },
509
510/* OR char/short/int with small constant */
511{ OR, FOREFF|INAREG|INAREG,
512 SAREG|SAREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
513 SUSHCON, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
514 0, RLEFT,
515 " iori AL,AR\n", },
516
517/* OR char/short/int with large constant */
518{ OR, FOREFF|INAREG|INAREG,
519 SAREG|SAREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
520 SCON, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
521 0, RLEFT,
522 " ior AL,[ .long AR ]\n", },
523
524/* long long OR */
525{ OR, INAREG|FOREFF,
526 SAREG|SAREG, TLL,
527 SAREG|SAREG|SNAME|SOREG, TLL,
528 0, RLEFT,
529 " ior AL,AR\n"
530 " ior UL,UR\n", },
531
532/* Safety belt for OR */
533{ OR, FORREW|FOREFF|INAREG|INAREG,
534 SANY, TANY,
535 SANY, TANY,
536 REWRITE, 0,
537 "DIEDIEDIE", },
538
539
540/* ER char/short/int with integer memory */
541{ ER, FOREFF|INAREG|INAREG,
542 SAREG|SAREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
543 SAREG|SAREG|SNAME|SOREG, TWORD,
544 0, RLEFT,
545 " xor AL,AR\n", },
546
547/* ER char/short/int with register */
548{ ER, FOREFF|INAREG|INAREG,
549 SAREG|SAREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
550 SAREG|SAREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
551 0, RLEFT,
552 " xor AL,AR\n", },
553
554/* ER char/short/int with small constant */
555{ ER, FOREFF|INAREG|INAREG,
556 SAREG|SAREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
557 SUSHCON, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
558 0, RLEFT,
559 " xori AL,AR\n", },
560
561/* ER char/short/int with large constant */
562{ ER, FOREFF|INAREG|INAREG,
563 SAREG|SAREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
564 SCON, TCHAR|TUCHAR|TSHORT|TUSHORT|TWORD,
565 0, RLEFT,
566 " xor AL,[ .long AR ]\n", },
567
568/* long long ER */
569{ ER, INAREG|FOREFF,
570 SAREG|SAREG, TLL,
571 SAREG|SAREG|SNAME|SOREG, TLL,
572 0, RLEFT,
573 " xor AL,AR\n"
574 " xor UL,UR\n", },
575
576/* Safety belt for ER */
577{ ER, FORREW|FOREFF|INAREG|INAREG,
578 SANY, TANY,
579 SANY, TANY,
580 REWRITE, 0,
581 "DIEDIEDIE", },
582
583/*
584 * The next rules handle all shift operators.
585 */
586{ LS, INAREG|INAREG|FOREFF,
587 SAREG|SAREG, TWORD|TCHAR|TUCHAR|TSHORT|TUSHORT,
588 SAREG|SAREG, TWORD|TCHAR|TUCHAR|TSHORT|TUSHORT,
589 0, RLEFT,
590 " lsh AL,(AR)\n", },
591
592{ LS, INAREG|INAREG|FOREFF,
593 SAREG|SAREG, TWORD|TCHAR|TUCHAR|TSHORT|TUSHORT,
594 SNAME|SOREG, TWORD,
595 0, RLEFT,
596 " lsh AL,@AR\n", },
597
598{ LS, INAREG|INAREG|FOREFF,
599 SAREG|SAREG, TLL,
600 SCON, TANY,
601 0, RLEFT,
602 " ashc AL,ZH\n", },
603
604{ LS, INAREG|INAREG|FOREFF,
605 SAREG|SAREG, TLL,
606 SAREG|SAREG /* |SNAME|SOREG */, TANY,
607 0, RLEFT,
608 " ashc AL,(AR)\n", },
609
610{ RS, INAREG|INAREG|FOREFF,
611 SAREG|SAREG, TSWORD,
612 SCON, TWORD,
613 0, RLEFT,
614 " ash AL,-ZH\n", },
615
616{ RS, INAREG|INAREG|FOREFF,
617 SAREG|SAREG, TUWORD,
618 SCON, TWORD,
619 0, RLEFT,
620 " lsh AL,-ZH\n", },
621
622/* Safety belt for LS/RS */
623{ LS, FORREW|FOREFF|INAREG|INAREG,
624 SANY, TANY,
625 SANY, TANY,
626 REWRITE, 0,
627 "DIEDIEDIE", },
628
629{ RS, FORREW|FOREFF|INAREG|INAREG,
630 SANY, TANY,
631 SANY, TANY,
632 REWRITE, 0,
633 "DIEDIEDIE", },
634
635/*
636 * The next rules takes care of assignments. "=".
637 */
638/* Match zeroed registers first */
639{ ASSIGN, INAREG|FOREFF,
640 SAREG, TUCHAR|TUSHORT|TCHAR|TSHORT|TWORD|TPOINT,
641 SZERO, TANY,
642 0, RDEST,
643 " setz AL,\n", },
644
645{ ASSIGN, FOREFF,
646 SAREG|SNAME|SOREG, TWORD|TPOINT,
647 SZERO, TANY,
648 0, 0,
649 " setzm AL\n", },
650
651{ ASSIGN, INAREG|FOREFF,
652 SAREG|SAREG, TUCHAR|TUSHORT|TCHAR|TSHORT|TWORD|TPOINT,
653 SMONE, TANY,
654 0, RDEST,
655 " setom AL\n", },
656
657{ ASSIGN, FOREFF,
658 SAREG|SNAME|SOREG, TWORD|TPOINT,
659 SMONE, TANY,
660 0, 0,
661 " setom AL\n", },
662
663{ ASSIGN, INAREG|INAREG|FOREFF,
664 SAREG|SAREG, TWORD|TPOINT,
665 SCON, TWORD|TPOINT,
666 0, RDEST,
667 " ZC\n", },
668
669{ ASSIGN, INAREG|INAREG|FOREFF,
670 SAREG|SNAME|SOREG, TWORD|TPOINT|TFLOAT,
671 SAREG|SAREG, TUCHAR|TUSHORT|TWORD|TPOINT|TFLOAT,
672 0, RDEST,
673 " movem AR,AL\n", },
674
675{ ASSIGN, INAREG|INAREG|FOREFF,
676 SAREG|SNAME|SOREG, TWORD|TPOINT|TFLOAT,
677 SAREG|SAREG, TSHORT,
678 0, RDEST,
679 " hrrem AR,AL\n", },
680
681{ ASSIGN, INAREG|INAREG|FOREFF,
682 SAREG|SAREG, TUCHAR|TUSHORT|TCHAR|TSHORT|TWORD|TPOINT,
683 SAREG|SAREG|SNAME|SOREG, TWORD|TPOINT,
684 0, RDEST,
685 " move AL,AR\n", },
686
687{ ASSIGN, INAREG|INAREG|FOREFF,
688 SAREG|SAREG, TUCHAR|TUSHORT|TCHAR|TSHORT,
689 SAREG|SAREG, TUCHAR|TUSHORT|TCHAR|TSHORT,
690 0, RDEST,
691 " move AL,AR\n", },
692
693{ ASSIGN, INBREG|FOREFF,
694 SBREG|SNAME|SOREG, TLL|TDOUBLE,
695 SBREG, TLL|TDOUBLE,
696 0, RDEST,
697 " dmovem AR,AL\n", },
698
699{ ASSIGN, INAREG|INAREG|FOREFF,
700 SOREG|SNAME, TSHORT|TUSHORT|TCHAR|TUCHAR,
701 SAREG|SAREG, TANY,
702 0, RDEST,
703 "ZV", },
704
705{ ASSIGN, INAREG|INAREG|FOREFF,
706 SAREG|SAREG, TUSHORT|TUCHAR,
707 SOREG, TANY,
708 0, RDEST,
709 " ldb AL,Zg\n", },
710
711{ ASSIGN, INAREG|INAREG|FOREFF,
712 SAREG|SAREG, TSHORT|TUSHORT|TCHAR|TUCHAR,
713 SSCON, TANY,
714 0, RDEST,
715 " movei AL,AR\n", },
716
717{ ASSIGN, INAREG|INAREG|FOREFF,
718 SAREG|SAREG, TSHORT|TUSHORT|TCHAR|TUCHAR,
719 SCON, TANY,
720 0, RDEST,
721 " move AL,[ .long AR]\n", },
722
723/*
724 * DIV/MOD/MUL
725 * These can be done way more efficient.
726 */
727/* long long div. XXX - work only with unsigned */
728{ DIV, INBREG,
729 SBREG|SNAME|SOREG, TLL,
730 SBREG|SNAME|SOREG, TLL,
731 (2*NBREG)|NBSL, RESC1,
732 " dmove A2,AL ; dmove A1,[ .long 0,0 ]\n"
733 " ddiv A1,AR\n", },
734
735/* long long div. with constant. XXX - work only with unsigned */
736{ DIV, INBREG,
737 SBREG|SNAME|SOREG, TLL,
738 SCON, TLL,
739 (2*NBREG)|NBSL, RESC1,
740 " dmove A2,AL ; dmove A1,[ .long 0,0 ]\n"
741 " ddiv A1,ZP\n", },
742
743/* Simple divide. XXX - fix so next reg can be free */
744{ DIV, INAREG|INAREG|FOREFF,
745 SAREG|SAREG, TWORD|TCHAR|TUCHAR|TSHORT|TUSHORT,
746 SAREG|SAREG, TWORD|TCHAR|TUCHAR|TSHORT|TUSHORT,
747 0, RRIGHT,
748 " idivm AL,AR\n", },
749
750/* Safety belt for DIV */
751{ DIV, FORREW|FOREFF|INAREG|INAREG,
752 SANY, TANY,
753 SANY, TANY,
754 REWRITE, 0,
755 "DIEDIEDIE", },
756
757/* long long MOD */
758{ MOD, INBREG,
759 SBREG|SNAME|SOREG, TLL,
760 SBREG|SNAME|SOREG, TLL,
761 2*NBREG|NBSL, RESC2,
762 " dmove A2,AL ; dmove A1,[ .long 0,0 ]\n"
763 " ddiv A1,AR\n", },
764
765/* integer MOD */
766{ MOD, INAREG,
767 SAREG|SNAME|SOREG, TWORD,
768 SAREG|SNAME|SOREG, TWORD,
769 2*NAREG|NASL, RESC2,
770 " move A2,AL\n"
771 " setz A1,\n"
772 " idiv A1,AR\n", },
773
774/* integer MOD for char/short */
775{ MOD, INAREG,
776 SAREG, TWORD|TCHAR|TUCHAR|TSHORT|TUSHORT,
777 SAREG, TWORD|TCHAR|TUCHAR|TSHORT|TUSHORT,
778 2*NAREG|NASL, RESC2,
779 " move A2,AL\n"
780 " setz A1,\n"
781 " idiv A1,AR\n", },
782
783/* Safety belt for MOD */
784{ MOD, FOREFF,
785 SANY, TANY,
786 SANY, TANY,
787 REWRITE, 0,
788 "DIEDIEDIE", },
789
790/* long long MUL */
791{ MUL, INBREG,
792 SBREG|SNAME|SOREG, TLL,
793 SBREG|SNAME|SOREG, TLL,
794 2*NBREG|NBSL, RESC2,
795 " dmove A1,AL\n"
796 " dmul A1,AR\n", },
797
798/* integer multiply to memory*/
799{ MUL, INAREG|INAREG|FOREFF,
800 SAREG|SAREG|SNAME|SOREG, TWORD,
801 SAREG|SAREG, TWORD,
802 0, RLEFT,
803 " imulm AR,AL\n", },
804
805/* integer multiply */
806{ MUL, INAREG|INAREG|FOREFF,
807 SAREG|SAREG, TWORD,
808 SAREG|SAREG|SNAME|SOREG, TWORD,
809 0, RLEFT,
810 " imul AL,AR\n", },
811
812/* integer multiply for char/short */
813{ MUL, INAREG|INAREG|FOREFF,
814 SAREG|SAREG, TWORD|TCHAR|TUCHAR|TSHORT|TUSHORT,
815 SAREG|SAREG, TWORD|TCHAR|TUCHAR|TSHORT|TUSHORT,
816 0, RLEFT,
817 " imul AL,AR\n", },
818
819/* integer multiply with small constant */
820{ MUL, INAREG|INAREG|FOREFF,
821 SAREG|SAREG, TWORD,
822 SUSHCON, TWORD,
823 0, RLEFT,
824 " imuli AL,AR\n", },
825
826/* integer multiply with large constant */
827{ MUL, INAREG|INAREG|FOREFF,
828 SAREG|SAREG, TWORD,
829 SCON, TWORD,
830 0, RLEFT,
831 " imul AL,[ .long AR ]\n", },
832
833/* Safety belt for MUL */
834{ MUL, FORREW|FOREFF|INAREG|INAREG,
835 SANY, TANY,
836 SANY, TANY,
837 REWRITE, 0,
838 "DIEDIEDIE", },
839
840/* read an indirect long long value into register */
841{ UMUL, INAREG,
842 SAREG|SAREG, TPTRTO|TLL|TWORD,
843 SANY, TLL,
844 NAREG|NASL, RESC1,
845 " dmove A1,(AL)\n", },
846
847/* read an indirect integer value into register */
848{ UMUL, INAREG,
849 SAREG|SAREG, TWORD|TPOINT,
850 SANY, TWORD|TPOINT,
851 NAREG|NASL, RESC1,
852 " move A1,(AL)\n", },
853
854/* read an indirect value into register */
855{ UMUL, INAREG,
856 SOREG, TWORD|TPOINT,
857 SANY, TWORD|TPOINT,
858 NAREG, RESC1,
859 " move A1,@AL\n", },
860
861/* read an indirect value into register */
862{ UMUL, INAREG,
863 SAREG|SAREG|SOREG, TCHAR|TUCHAR|TSHORT|TUSHORT|TPTRTO,
864 SANY, TCHAR|TUCHAR|TSHORT|TUSHORT,
865 NAREG|NASL, RESC1,
866 " ldb A1,AL\n", },
867
868#ifdef notyet
869/* Match tree shape for ildb */
870{ UMUL, INAREG,
871 SANY, TANY,
872 SILDB, TUCHAR|TCHAR|TPTRTO,
873 NAREG, RESC1,
874 " ildb A1,ZA\n", },
875#endif
876
877/* Match char/short pointers first, requires special handling */
878{ OPLOG, FORCC,
879 SAREG|SAREG, TPTRTO|TCHAR|TUCHAR|TSHORT|TUSHORT,
880 SAREG|SAREG, TPTRTO|TCHAR|TUCHAR|TSHORT|TUSHORT,
881 0, RESCC,
882 "ZZ", },
883
884/* Can check anything by just comparing if EQ/NE */
885{ OPLOG, FORCC,
886 SAREG|SAREG, TWORD|TPOINT|TCHAR|TUCHAR|TSHORT|TUSHORT,
887 SZERO, TANY,
888 0, RESCC,
889 " jumpZe AL,LC # bu\n", },
890
891{ EQ, FORCC,
892 SAREG|SAREG, TWORD|TPOINT|TCHAR|TUCHAR|TSHORT|TUSHORT,
893 SAREG|SAREG|SOREG|SNAME|SCON, TWORD|TPOINT,
894 0, RESCC,
895 "ZR", },
896
897{ NE, FORCC,
898 SAREG|SAREG, TWORD|TPOINT|TCHAR|TUCHAR|TSHORT|TUSHORT,
899 SAREG|SAREG|SOREG|SNAME|SCON, TWORD|TPOINT,
900 0, RESCC,
901 "ZR", },
902
903{ OPLOG, FORCC,
904 SAREG|SAREG, TWORD,
905 SAREG|SAREG|SOREG|SNAME|SCON, TSWORD,
906 0, RESCC,
907 "ZR", },
908
909{ OPLOG, FORCC,
910 SAREG|SAREG, TCHAR|TUCHAR,
911 SCON, TANY,
912 0, RESCC,
913 "ZR", },
914
915{ OPLOG, FORCC,
916 SAREG|SAREG, TWORD|TPOINT|TFLOAT,
917 SAREG|SAREG|SOREG|SNAME|SCON, TWORD|TPOINT|TFLOAT,
918 0, RESCC,
919 "ZR", },
920
921{ OPLOG, FORCC,
922 SAREG|SAREG, TWORD|TPOINT|TCHAR|TUCHAR|TSHORT|TUSHORT,
923 SAREG|SAREG, TWORD|TPOINT|TCHAR|TUCHAR|TSHORT|TUSHORT,
924 0, RESCC,
925 "ZR", },
926
927{ OPLOG, FORCC,
928 SAREG|SAREG, TLL|TDOUBLE, /* XXX - does double work here? */
929 SAREG|SAREG|SOREG|SNAME, TLL|TDOUBLE,
930 0, RESCC,
931 "ZQ", },
932
933/*
934 * Jumps.
935 */
936{ GOTO, FOREFF,
937 SCON, TANY,
938 SANY, TANY,
939 0, RNOP,
940 " jrst LL\n", },
941
942/*
943 * Convert LTYPE to reg.
944 */
945{ OPLTYPE, INBREG,
946 SANY, TANY,
947 SMONE, TLL,
948 NBREG, RESC1,
949 " seto A1,\n seto U1,\n", },
950
951{ OPLTYPE, INAREG,
952 SANY, TANY,
953 SMONE, TANY,
954 NAREG, RESC1,
955 " seto A1,\n", },
956
957{ OPLTYPE, INBREG,
958 SANY, TANY,
959 SZERO, TLL,
960 NBREG, RESC1,
961 " setz A1,\n setz U1,\n", },
962
963{ OPLTYPE, INAREG,
964 SANY, TANY,
965 SZERO, TANY,
966 NAREG, RESC1,
967 " setz A1,\n", },
968
969{ OPLTYPE, INBREG,
970 SANY, TANY,
971 SUSHCON, TLL,
972 NBREG, RESC1,
973 " setz A1,\n movei U1,AR\n", },
974
975{ OPLTYPE, INAREG,
976 SANY, TANY,
977 SUSHCON, ANYFIXED,
978 NAREG, RESC1,
979 " movei A1,AR\n", },
980
981{ OPLTYPE, INAREG,
982 SANY, ANYFIXED,
983 SNSHCON, ANYFIXED,
984 NAREG, RESC1,
985 " hrroi A1,AR\n", },
986
987{ OPLTYPE, INAREG,
988 SANY, ANYFIXED,
989 SCON, ANYFIXED,
990 NAREG|NASR, RESC1,
991 " ZD A1,ZE # suspekt\n", },
992
993{ OPLTYPE, INAREG,
994 SANY, TWORD|TPOINT|TFLOAT,
995 SAREG|SAREG|SOREG|SNAME, TWORD|TPOINT|TFLOAT,
996 NAREG|NASR, RESC1,
997 " move A1,AR\n", },
998
999{ OPLTYPE, INBREG,
1000 SANY, TLL,
1001 SCON, TLL,
1002 NBREG, RESC1,
1003 " dmove A1,ZO\n", },
1004
1005{ OPLTYPE, INBREG,
1006 SANY, TLL|TDOUBLE,
1007 SANY, TLL|TDOUBLE,
1008 NBREG|NBSR, RESC1,
1009 " dmove A1,AR\n", },
1010
1011{ OPLTYPE, INAREG,
1012 SOREG, TSHORT|TUSHORT|TCHAR|TUCHAR,
1013 SOREG, TSHORT|TUSHORT|TCHAR|TUCHAR,
1014 NASR, RESC1,
1015 "ZU", },
1016
1017{ OPLTYPE, INAREG,
1018 SNAME, TUCHAR,
1019 SNAME, TUCHAR,
1020 NAREG|NASR, RESC1,
1021 " ldb A1,[ .long AL ]\n" },
1022
1023{ OPLTYPE, INAREG,
1024 SNAME, TCHAR,
1025 SNAME, TCHAR,
1026 NAREG|NASR, RESC1,
1027 " ldb A1,[ .long AL ]\n"
1028 " ash A1,033\n"
1029 " ash A1,-033\n", },
1030
1031{ OPLTYPE, INAREG,
1032 SANY, TANY,
1033 SNAME, TSHORT|TUSHORT,
1034 NAREG|NASR, RESC1,
1035 "Zi", },
1036
1037{ OPLTYPE, INAREG,
1038 SANY, TWORD|TPOINT,
1039 SCON, TWORD|TPOINT,
1040 NAREG|NASR, RESC1,
1041 "Zc", },
1042
1043{ OPLTYPE, INAREG,
1044 SAREG|SAREG, TUSHORT|TUCHAR,
1045 SAREG|SAREG, TUSHORT|TUCHAR|TWORD,
1046 NAREG, RESC1,
1047 " move A1,AL\n", },
1048
1049/*
1050 * Negate a word.
1051 */
1052{ UMINUS, INAREG,
1053 SAREG|SAREG|SNAME|SOREG, TWORD,
1054 SANY, TWORD,
1055 NAREG|NASL, RESC1,
1056 " movn A1,AL\n", },
1057
1058{ UMINUS, INAREG,
1059 SAREG|SAREG, TWORD,
1060 SANY, TCHAR|TUCHAR|TSHORT|TUSHORT,
1061 0, RLEFT,
1062 " movn AL,AL\n", },
1063
1064{ UMINUS, INAREG,
1065 SAREG|SNAME|SOREG, TLL,
1066 SANY, TLL,
1067 NAREG|NASR, RESC1,
1068 " dmovn A1,AL\n", },
1069
1070{ COMPL, INAREG,
1071 SAREG|SAREG|SNAME|SOREG, TLL,
1072 SANY, TANY,
1073 NAREG|NASL, RESC1,
1074 " setcm A1,AL\n"
1075 " setcm U1,UL\n", },
1076
1077{ COMPL, INAREG,
1078 SAREG|SAREG|SNAME|SOREG, TWORD,
1079 SANY, TANY,
1080 NAREG|NASL, RESC1,
1081 " setcm A1,AL\n", },
1082
1083{ COMPL, INAREG,
1084 SAREG|SAREG, TCHAR|TUCHAR|TSHORT|TUSHORT,
1085 SANY, TCHAR|TUCHAR|TSHORT|TUSHORT,
1086 NAREG|NASL, RESC1,
1087 " setcm A1,AL\n", },
1088
1089/*
1090 * Arguments to functions.
1091 */
1092{ FUNARG, FOREFF,
1093 SAREG|SNAME|SOREG, TWORD|TPOINT|TFLOAT,
1094 SANY, TANY,
1095 0, RNULL,
1096 " push 017,AL\n", },
1097
1098{ FUNARG, FOREFF,
1099 SAREG|SAREG, TCHAR|TUCHAR|TSHORT|TUSHORT,
1100 SANY, TANY,
1101 0, RNULL,
1102 " push 017,AL\n", },
1103
1104{ FUNARG, FOREFF,
1105 SCON, TCHAR|TUCHAR|TSHORT|TUSHORT|TPOINT|TWORD,
1106 SANY, TANY,
1107 0, RNULL,
1108 " push 017,[ .long AL]\n", },
1109
1110{ FUNARG, FOREFF,
1111 SBREG, TLL|TDOUBLE,
1112 SANY, TANY,
1113 0, RNULL,
1114 " push 017,AL\n push 017,UL\n", },
1115
1116{ STARG, FOREFF,
1117 SAREG|SOREG|SNAME|SCON, TANY,
1118 SANY, TSTRUCT,
1119 0, 0,
1120 "ZG", },
1121
1122
1123# define DF(x) FORREW,SANY,TANY,SANY,TANY,REWRITE,x,""
1124
1125{ UMUL, DF( UMUL ), },
1126
1127{ ASSIGN, DF(ASSIGN), },
1128
1129{ OPLEAF, DF(NAME), },
1130
1131{ OPUNARY, DF(UMINUS), },
1132
1133{ FREE, FREE, FREE, FREE, FREE, FREE, FREE, FREE, "help; I'm in trouble\n" },
1134};
1135
1136int tablesize = sizeof(table)/sizeof(table[0]);
Note: See TracBrowser for help on using the repository browser.