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

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since 48fa501 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
RevLine 
[a7de7182]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
42struct 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
843int tablesize = sizeof(table)/sizeof(table[0]);
Note: See TracBrowser for help on using the repository browser.