← Back to branch summary

~vojtech-horky/helenos/numa

« back to all changes in this revision

Viewing changes to uspace/app/pcc/arch/m16c/table.c

  • Committer: Vojtech Horky
  • Date: 2011-09-28 15:13:08 UTC
  • mfrom: (538.1.714 helenos-mainline)
  • Revision ID: vojtechhorky@users.sourceforge.net-20110928151308-2pz4s2w035n48o8a
Merge mainline changes

Conflicts fixed without problems (mostly caused by separating
ABI into /abi/).

Show diffs side-by-side

added added

removed removed

Lines of Context:
uspace/app/pcc/arch/m16c/table.c
 
1
#include "pass2.h"
 
2
 
 
3
# define ANYSIGNED TINT|TLONG|TCHAR
 
4
# define ANYUSIGNED TUNSIGNED|TULONG|TUCHAR
 
5
# define ANYFIXED ANYSIGNED|ANYUSIGNED
 
6
# define TL TLONG|TULONG
 
7
# define TWORD TUNSIGNED|TINT
 
8
# define TCH TCHAR|TUCHAR
 
9
 
 
10
struct optab table[] = {
 
11
/* First entry must be an empty entry */
 
12
{ -1, FOREFF, SANY, TANY, SANY, TANY, 0, 0, "", },
 
13
 
 
14
/* (signed) char -> int/pointer */
 
15
{ SCONV,        INAREG,
 
16
        SCREG,          TCHAR,
 
17
        SANY,           TINT|TPOINT,
 
18
                NAREG,  RESC1,
 
19
                "       mov.b AL, A1\n\texts.b A1\n", },
 
20
 
 
21
/* (unsigned) char -> int/pointer */
 
22
{ SCONV,        INAREG,
 
23
        SCREG,          TUCHAR,
 
24
        SANY,           TINT|TPOINT,
 
25
                NAREG,  RESC1,
 
26
                "       mov.b AL, A1\n", },
 
27
    
 
28
/* unsigned char -> long */
 
29
{ SCONV,        INAREG,
 
30
        SCREG,          TUCHAR,
 
31
        SANY,           TL,
 
32
                NAREG|NASL,     RESC1,
 
33
                "       mov.b AL, A1\n  mov.w #0,U1\n", },
 
34
 
 
35
/* int or pointer -> (unsigned) long */
 
36
{ SCONV,        INAREG,
 
37
        SAREG|SNAME,    TWORD|TPOINT,
 
38
        SANY,                   TL,
 
39
                NAREG|NASL,     RESC1,
 
40
                "       mov.w AL,A1\n   mov.w #0,U1\n", },
 
41
 
 
42
/* char -> (signed) long */
 
43
{ SCONV,        INAREG,
 
44
        SAREG|SNAME,    TCHAR,
 
45
        SANY,                   TLONG,
 
46
                NAREG|NASL,     RESC1,
 
47
                "       exts.b AL\n     exts.w AL\n", },
 
48
 
 
49
/* long -> ulong */
 
50
{ SCONV,        INAREG,
 
51
        SAREG,          TL,
 
52
        SANY,                   TL,
 
53
                0,      RLEFT,
 
54
        "", },
 
55
 
 
56
/* long -> int or pointer */
 
57
{ SCONV,        INAREG,
 
58
        SAREG|SOREG|SNAME,      TL,
 
59
        SANY,                   TWORD|TPOINT,
 
60
                NAREG|NASL,     RESC1,
 
61
                "       mov.w AL,A1\n", },
 
62
 
 
63
/* int -> char */
 
64
{ SCONV,        INCREG,
 
65
        SAREG,          TWORD,
 
66
        SANY,           TCH,
 
67
                NCREG,  RESC1,
 
68
                "       mov.b AL, A1\n", },
 
69
 
 
70
/* int -> long */
 
71
{ SCONV,        INAREG,
 
72
        SAREG,          TWORD,
 
73
        SANY,           TLONG,
 
74
                NAREG|NASL,     RESC1,
 
75
                "       exts.w AL", },
 
76
 
 
77
/* long -> char */
 
78
{ SCONV,        INAREG,
 
79
        SAREG,          TL,
 
80
        SANY,           TCH,
 
81
                NAREG|NASL,     RESC1,
 
82
                "", },
 
83
 
 
84
{ SCONV,        INAREG,
 
85
        SAREG,          TPOINT,
 
86
        SANY,           TWORD,
 
87
                0,      RLEFT,
 
88
                "", },
 
89
 
 
90
{ PLUS, INAREG|FOREFF,
 
91
        SAREG,  TL,
 
92
        SCON|SNAME|SOREG,       TL,
 
93
                0,      RLEFT,
 
94
                "       add.w AR,AL\n   adc.w UR,UL\n", },
 
95
 
 
96
{ MINUS,        INAREG|FOREFF,
 
97
        SAREG,  TL,
 
98
        SCON|SNAME|SOREG,       TL,
 
99
                0,      RLEFT,
 
100
                "       sub.w AR,AL\n   sbb.w UR,UL\n", },
 
101
 
 
102
{ AND,          INAREG|FOREFF,
 
103
        SAREG,                  TL,
 
104
        SAREG|SNAME|SOREG,      TL,
 
105
                0,      RLEFT,
 
106
                "       and.w AR,AL\n   and.w UR,UL\n", },
 
107
 
 
108
{ ER,           INAREG|FOREFF,
 
109
        SAREG,                  TL,
 
110
        SAREG|SNAME|SOREG,      TL,
 
111
                0,      RLEFT,
 
112
                "       xor.w AR,AL\n   xor.w UR,UL\n", },
 
113
 
 
114
{ OR,           INAREG|FOREFF,
 
115
        SAREG,                  TL,
 
116
        SAREG|SNAME|SOREG,      TL,
 
117
                0,      RLEFT,
 
118
                "       xor.w AR,AL\n   xor.w UR,UL\n", },
 
119
 
 
120
{ COMPL,        INAREG|FOREFF,
 
121
        SAREG,                  TL,
 
122
        SAREG|SNAME|SOREG,      TL,
 
123
                0,      RLEFT,
 
124
                "       not.w AR,AL\n   not.w UR,UL\n", },
 
125
        
 
126
{ OPSIMP,       INAREG|FOREFF,
 
127
        SAREG,                  TWORD|TPOINT,
 
128
        SAREG|SNAME|SOREG|SCON, TWORD|TPOINT,
 
129
                0,      RLEFT,
 
130
                "       Ow AR,AL\n", },
 
131
 
 
132
/* XXX - Is this rule really correct? Having a SAREG shape seems kind of
 
133
   strange. Doesn't work. Gives a areg as A1. */
 
134
#if 0   
 
135
{ OPSIMP,       INBREG,
 
136
        SAREG,                  TWORD|TPOINT,
 
137
        SAREG|SBREG|SNAME|SOREG|SCON,   TWORD|TPOINT,
 
138
                NBREG,  RESC1,
 
139
                "       ++Ow AR,A1\n", },
 
140
#endif
 
141
        
 
142
{ OPSIMP,       INBREG,
 
143
        SBREG,                  TWORD|TPOINT,
 
144
        SAREG|SBREG|SNAME|SOREG|SCON,   TWORD|TPOINT,
 
145
                0,      RLEFT,
 
146
                "       Ow AR,AL\n", },
 
147
        
 
148
{ OPSIMP,       INCREG|FOREFF,
 
149
        SCREG,                  TCH,
 
150
        SCREG|SNAME|SOREG|SCON, TCH,
 
151
                0,      RLEFT,
 
152
                "       Ob AR,AL\n", },
 
153
        
 
154
/* XXX - Do these work? check nspecial in order.c */
 
155
/* signed integer division */
 
156
{ DIV,          INAREG,
 
157
        SAREG,                  TINT,
 
158
        SAREG|SNAME|SOREG,      TWORD,
 
159
          /*2*NAREG|NASL|*/NSPECIAL,            RLEFT,
 
160
                "       div.w AR\n      mov.w r0,AL\n", },
 
161
      //                "       xor.w r2\n      div.w AR\n", },
 
162
 
 
163
 
 
164
/* signed integer/char division - separate entry for FOREFF */
 
165
{ DIV,          FOREFF,
 
166
        SAREG,                  TINT,
 
167
        SAREG|SNAME|SOREG,      TWORD,
 
168
                0,              0,
 
169
                "", },
 
170
 
 
171
#if 0
 
172
/* signed char division */
 
173
{ DIV,          INCREG,
 
174
        SCREG,                  TCHAR,
 
175
        SCREG|SNAME|SOREG,      TCH,
 
176
                2*NCREG|NCSL|NSPECIAL,          RLEFT,
 
177
                "       div.b AR\n\tmov.b r0l,AL\n", },
 
178
      //                "       xor.w r2\n      div.w AR\n", },
 
179
#endif
 
180
        
 
181
/* signed integer modulus, equal to above */
 
182
{ MOD,          INAREG,
 
183
        SAREG,                  TINT,
 
184
        SAREG|SNAME|SOREG,      TWORD,
 
185
          /*2*NAREG|NASL|*/NSPECIAL,            RLEFT,
 
186
                "       div.w AR\n\tmov r2,AL\n", },
 
187
 
 
188
/* signed integer modulus - separate entry for FOREFF */
 
189
{ MOD,          FOREFF,
 
190
        SAREG,                  TINT,
 
191
        SAREG|SNAME|SOREG,      TWORD,
 
192
                0,              0,
 
193
                "", },
 
194
 
 
195
/* signed integer multiplication */
 
196
{ MUL,          INAREG,
 
197
        SAREG,                  TINT,
 
198
        SAREG|SNAME|SOREG,      TWORD,
 
199
                2*NAREG|NASL|NSPECIAL,          RESC1,
 
200
                "       mul.w AL,AR\n", },
 
201
 
 
202
{ MUL,          FOREFF,
 
203
        SAREG,                  TINT,
 
204
        SAREG|SNAME|SOREG,      TWORD,
 
205
                0,      0,
 
206
                "", },
 
207
 
 
208
#if 0
 
209
{ LS,           INAREG,
 
210
        SAREG,  TWORD,
 
211
        SCON,           TANY,
 
212
                0,      RLEFT,
 
213
                "       shl.w AR,AL\n", },
 
214
#endif
 
215
 
 
216
{ LS,           INAREG,
 
217
        SAREG,  TWORD,
 
218
        SAREG,  TWORD,
 
219
                0,      RLEFT,
 
220
                "       push.b r1h\n"
 
221
                "       mov.b AR,r1h\n"
 
222
                "       shl.w r1h,AL\n"
 
223
                "       pop.b r1h\n", },
 
224
 
 
225
{ LS,           INAREG,
 
226
        SAREG,  TL,
 
227
        SAREG,  TWORD,
 
228
                0,      RLEFT,
 
229
                "       push.b r1h\n"
 
230
                "       mov.b AR,r1h\n"
 
231
                "       shl.l r1h,ZG\n"
 
232
                "       pop.b r1h\n", },
 
233
 
 
234
{ RS,           INAREG,
 
235
        SAREG,  TWORD,
 
236
        SAREG,  TWORD,
 
237
                0,      RLEFT,
 
238
                "       push.b r1h\n"
 
239
                "       mov.b AR,r1h\n"
 
240
                "       neg.b r1h\n"
 
241
                "       shl.w r1h,AL\n"
 
242
                "       pop.b r1h\n", },
 
243
 
 
244
{ RS,           INAREG,
 
245
        SAREG,  TL,
 
246
        SAREG,  TWORD,
 
247
                0,      RLEFT,
 
248
                "       push.b r1h\n"
 
249
                "       mov.b AR,r1h\n"
 
250
                "       neg.b r1h\n"
 
251
                "       shl.l r1h,ZG\n"
 
252
                "       pop.b r1h\n", },
 
253
 
 
254
#if 0
 
255
{ RS,           INAREG,
 
256
        SAREG,  TUNSIGNED,
 
257
        SCON,           TANY,
 
258
                0,      RLEFT,
 
259
                "       shl ZA,AL\n", },
 
260
 
 
261
{ RS,           INAREG,
 
262
        SAREG,  TINT,
 
263
        SCON,           TANY,
 
264
                0,      RLEFT,
 
265
                "       sha ZA,AL\n", },
 
266
#endif
 
267
 
 
268
{ OPLOG,        FORCC,
 
269
        SAREG|SBREG|SOREG|SNAME,        TL,
 
270
        SAREG|SBREG|SOREG|SNAME,        TL,
 
271
                0,      0,
 
272
                "ZF", },
 
273
 
 
274
{ OPLOG,        FORCC,
 
275
        SBREG|SOREG,    TWORD|TPOINT,
 
276
        SCON,                   TWORD|TPOINT,
 
277
                0,      RESCC,
 
278
                "       cmp.w AR,AL\n", },
 
279
 
 
280
{ OPLOG,        FORCC,
 
281
        SAREG|SBREG|SOREG|SNAME,        TWORD|TPOINT,
 
282
        SAREG|SBREG|SOREG|SNAME,        TWORD|TPOINT,
 
283
                0,      RESCC,
 
284
                "       cmp.w AR,AL\n", },
 
285
 
 
286
{ OPLOG,        FORCC,
 
287
        SCREG|SOREG|SNAME,      TCH,
 
288
        SCREG|SOREG|SNAME,      TCH,
 
289
                0,      RESCC,
 
290
                "       cmp.b AR,AL\n", },
 
291
 
 
292
{ OPLOG,        FORCC,
 
293
        SCREG|SOREG|SNAME,      TCH,
 
294
        SCREG|SOREG|SNAME,      TCH,
 
295
                0,      RESCC,
 
296
                "       cmp.b AR,AL\n", },
 
297
 
 
298
{ GOTO,         FOREFF,
 
299
        SCON,   TANY,
 
300
        SANY,   TANY,
 
301
                0,      RNOP,
 
302
                "       jmp.w ZC\n", },
 
303
 
 
304
{ OPLTYPE,      INAREG,
 
305
        SANY,   TANY,
 
306
        SCON|SNAME|SOREG|SAREG, TL|TFTN,
 
307
                NAREG,  RESC1,
 
308
                "       mov.w AR,A1\n   mov.w UR,U1\n", },
 
309
 
 
310
{ OPLTYPE,      INAREG,
 
311
        SANY,   TANY,
 
312
        SCON|SNAME|SOREG|SAREG|SBREG,   TWORD|TPOINT,
 
313
                NAREG,  RESC1,
 
314
                "       mov.w AR,A1\n", },      
 
315
 
 
316
{ OPLTYPE,      INBREG,
 
317
        SANY,   TANY,
 
318
        SBREG|SCON|SNAME|SOREG|SAREG,   TWORD|TPOINT,
 
319
                NBREG,  RESC1,
 
320
                "       mov.w AR,A1\n", },      
 
321
    /*
 
322
{ OPLTYPE,      INAREG,
 
323
        SANY,           TANY,
 
324
        SCON|SNAME|SOREG,       TCH,
 
325
                NAREG,  RESC1,
 
326
                "       mov.b AR, A1\n", },
 
327
 
 
328
{ OPLTYPE,      INBREG,
 
329
        SANY,                   TANY,
 
330
        SCON|SNAME|SOREG,       TCHAR|TUCHAR,
 
331
                NBREG,  RESC1,
 
332
                "       mov.b AR,A1\n", },
 
333
    */
 
334
    
 
335
{ OPLTYPE,      INCREG,
 
336
        SANY,                   TANY,
 
337
        SCON|SNAME|SOREG,       TCHAR|TUCHAR,
 
338
                NCREG,  RESC1,
 
339
                "       mov.b AR,A1\n", },
 
340
    
 
341
{ COMPL,        INAREG,
 
342
        SAREG,  TWORD,
 
343
        SANY,           TANY,
 
344
                0,      RLEFT,
 
345
                "       not.w AL\n", },
 
346
 
 
347
{ COMPL,        INCREG,
 
348
        SCREG,  TCH,
 
349
        SANY,           TANY,
 
350
                0,      RLEFT,
 
351
                "       not.b AL\n", },
 
352
        
 
353
/* Push function address */
 
354
{ FUNARG,       FOREFF,
 
355
        SCON,   TFTN,
 
356
        SANY,   TANY,
 
357
                0,      RNULL,
 
358
                "ZH", },
 
359
 
 
360
{ FUNARG,       FOREFF,
 
361
        SOREG,  TFTN,
 
362
        SANY,   TANY,
 
363
                0,      RNULL,
 
364
                "ZI", },
 
365
 
 
366
{ FUNARG,       FOREFF,
 
367
        SNAME|SAREG,    TL|TFTN,
 
368
        SANY,   TANY,
 
369
                0,      RNULL,
 
370
                "       push.w UL\n     push.w AL\n", },
 
371
 
 
372
{ FUNARG,       FOREFF,
 
373
        SCON|SAREG|SNAME|SOREG, TWORD|TPOINT,
 
374
        SANY,                   TANY,
 
375
                0,      RNULL,
 
376
                "       push.w AL\n", },
 
377
 
 
378
{ FUNARG,       FOREFF,
 
379
        SAREG|SNAME|SOREG,      TCHAR|TUCHAR,
 
380
        SANY,                           TANY,
 
381
                0,      RNULL,
 
382
                "       push.b AL\n", },
 
383
 
 
384
/* Match function pointers first */
 
385
#if 0
 
386
{ ASSIGN,       FOREFF,
 
387
        SFTN,   TWORD|TPOINT,
 
388
        SFTN,   TWORD|TPOINT,
 
389
                NAREG,  0,
 
390
                "ZD", },
 
391
#endif
 
392
 
 
393
{ ASSIGN,       INAREG,
 
394
        SAREG,  TFTN,
 
395
        SCON,   TFTN,
 
396
                0,      RLEFT,
 
397
                "ZD", },
 
398
    
 
399
{ ASSIGN,       INBREG,
 
400
        SBREG,  TFTN,
 
401
        SCON,   TFTN,
 
402
                0,      RLEFT,
 
403
                "ZD", },
 
404
 
 
405
{ ASSIGN,       INAREG,
 
406
        SAREG,  TFTN,
 
407
        SBREG|SAREG|SOREG|SNAME,        TFTN,
 
408
                0,      RLEFT,
 
409
                "       mov.w AR,AL\n   mov.w UR,UL\n", },
 
410
 
 
411
{ ASSIGN,       INBREG,
 
412
        SBREG,  TFTN,
 
413
        SBREG|SAREG|SOREG|SNAME,        TFTN,
 
414
                0,      RLEFT,
 
415
                "       mov.w AR,AL\n   mov.w UR,UL\n", },
 
416
    
 
417
{ ASSIGN,       INAREG,
 
418
        SBREG|SAREG|SOREG|SNAME,        TFTN,
 
419
        SAREG,  TFTN,
 
420
                0,      RRIGHT,
 
421
                "       mov.w AR,AL\n   mov.w UR,UL\n", },
 
422
 
 
423
{ ASSIGN,       INBREG,
 
424
        SBREG|SAREG|SOREG|SNAME,        TFTN,
 
425
        SBREG,  TFTN,
 
426
                0,      RRIGHT,
 
427
                "       mov.w AR,AL\n   mov.w UR,UL\n", },
 
428
 
 
429
/* a reg -> a reg */
 
430
{ ASSIGN,       FOREFF|INAREG,
 
431
        SAREG,  TWORD|TPOINT,
 
432
        SAREG,  TWORD|TPOINT,
 
433
                0,      RLEFT,
 
434
                "       mov.w AR,AL\n", },
 
435
 
 
436
{ ASSIGN,       INAREG,
 
437
        SBREG|SAREG|SOREG|SNAME,        TL,
 
438
        SAREG,  TL,
 
439
                0,      RRIGHT,
 
440
                "       mov.w AR,AL\n   mov.w UR,UL\n", },
 
441
 
 
442
{ ASSIGN,       INBREG,
 
443
        SBREG|SAREG|SOREG|SNAME,        TL,
 
444
        SBREG,  TL,
 
445
                0,      RRIGHT,
 
446
                "       mov.w AR,AL\n   mov.w UR,UL\n", },
 
447
    
 
448
{ ASSIGN,       FOREFF,
 
449
        SBREG|SAREG|SOREG|SNAME,        TL,
 
450
        SCON|SBREG|SAREG|SOREG|SNAME,   TL,
 
451
                0,      0,
 
452
                "       mov.w AR,AL\n   mov.w UR,UL\n", },
 
453
 
 
454
{ ASSIGN,       INAREG|FOREFF,
 
455
        SAREG,  TWORD|TPOINT,
 
456
        SCON,   TANY,
 
457
                0,      RLEFT,
 
458
                "       mov.w AR,AL\n", },
 
459
 
 
460
{ ASSIGN,       INBREG|FOREFF,
 
461
        SBREG,  TWORD|TPOINT,
 
462
        SCON,   TANY,
 
463
                0,      RLEFT,
 
464
                "       mov.w AR,AL\n", },
 
465
    
 
466
{ ASSIGN,       FOREFF,
 
467
        SNAME|SOREG,    TWORD|TPOINT,
 
468
        SCON,           TANY,
 
469
                0,      0,
 
470
                "       mov.w AR,AL\n", },
 
471
 
 
472
/* char, oreg/name -> c reg */
 
473
{ ASSIGN,       FOREFF|INCREG,
 
474
        SCREG,  TCHAR|TUCHAR,
 
475
        SOREG|SNAME|SCON,       TCHAR|TUCHAR,
 
476
                0,      RLEFT,
 
477
                "       mov.b AR,AL\n", },
 
478
 
 
479
/* int, oreg/name -> a reg */
 
480
{ ASSIGN,       FOREFF|INAREG,
 
481
        SAREG,  TWORD|TPOINT,
 
482
        SOREG|SNAME,    TWORD|TPOINT,
 
483
                0,      RLEFT,
 
484
                "       mov.w AR,AL\n", },
 
485
 
 
486
{ ASSIGN,       FOREFF|INBREG,
 
487
        SBREG,  TWORD|TPOINT,
 
488
        SOREG|SNAME,    TWORD|TPOINT,
 
489
                0,      RLEFT,
 
490
                "       mov.w AR,AL\n", },
 
491
    
 
492
{ ASSIGN,       FOREFF|INAREG,
 
493
        SOREG|SNAME,    TWORD|TPOINT,
 
494
        SAREG,  TWORD|TPOINT,
 
495
                0,      RRIGHT,
 
496
                "       mov.w AR,AL\n", },
 
497
 
 
498
{ ASSIGN,       FOREFF|INBREG,
 
499
        SOREG|SNAME,    TWORD|TPOINT,
 
500
        SBREG,  TWORD|TPOINT,
 
501
                0,      RRIGHT,
 
502
                "       mov.w AR,AL\n", },
 
503
    
 
504
{ ASSIGN,       FOREFF|INCREG,
 
505
        SOREG|SNAME,    TCHAR|TUCHAR,
 
506
        SCREG,  TCHAR|TUCHAR,
 
507
                0,      RRIGHT,
 
508
                "       mov.b AR,AL\n", },
 
509
 
 
510
{ ASSIGN,       FOREFF|INCREG,
 
511
        SCREG,    TCHAR|TUCHAR,
 
512
        SCREG,  TCHAR|TUCHAR,
 
513
                0,      RRIGHT,
 
514
                "       mov.b AR,AL\n", },
 
515
 
 
516
{ ASSIGN,       FOREFF|INBREG,
 
517
        SBREG,    TWORD|TPOINT,
 
518
        SBREG,  TWORD|TPOINT,
 
519
                0,      RRIGHT,
 
520
                "       mov.w AR,AL\n", },
 
521
        
 
522
{ UMUL,         INAREG,
 
523
        SBREG,  TPOINT|TWORD,
 
524
        SANY,   TFTN,
 
525
                NAREG,  RESC1,
 
526
                "       mov.w [AL],A1\n mov.w 2[AL],U1\n", },
 
527
 
 
528
{ UMUL,         INAREG,
 
529
        SBREG,  TPOINT|TWORD,
 
530
        SANY,   TPOINT|TWORD,
 
531
                NAREG,  RESC1,
 
532
                "       mov.w [AL],A1\n", },
 
533
 
 
534
{ UMUL,         INBREG,
 
535
        SBREG,  TPOINT|TWORD,
 
536
        SANY,   TPOINT|TWORD,
 
537
                NBREG|NBSL,     RESC1,
 
538
                "       mov.w [AL],A1\n", },
 
539
 
 
540
{ UMUL,         INAREG,
 
541
        SBREG,  TCHAR|TUCHAR|TPTRTO,
 
542
        SANY,   TCHAR|TUCHAR,
 
543
                NAREG,  RESC1,
 
544
                "       mov.b [AL], A1\n", },
 
545
    
 
546
{ UCALL,        FOREFF,
 
547
        SCON,   TANY,
 
548
        SANY,   TANY,
 
549
                0,      0,
 
550
                "       jsr.w CL\nZB", },
 
551
    
 
552
{ UCALL,        INAREG,
 
553
        SCON,   TANY,
 
554
        SANY,   TANY,
 
555
                NAREG,  RESC1,
 
556
                "       jsr.w CL\nZB", },
 
557
 
 
558
{ UCALL,        INAREG,
 
559
        SNAME|SOREG,    TANY,
 
560
        SANY,           TANY,
 
561
                NAREG|NASL,     RESC1,  /* should be 0 */
 
562
                "       jsri.a AL\nZB", },
 
563
 
 
564
{ UCALL,        FOREFF,
 
565
        SNAME|SOREG,    TANY,
 
566
        SANY,           TANY,
 
567
                0,     0,  
 
568
                "       jsri.a AL\nZB", },
 
569
    
 
570
{ UCALL,        INAREG,
 
571
        SBREG,   TANY,
 
572
        SANY,   TANY,
 
573
                NAREG|NASL,     RESC1,  /* should be 0 */
 
574
                "       jsri.a [AL]\nZB", },
 
575
 
 
576
{ UCALL,        FOREFF,
 
577
        SBREG,   TANY,
 
578
        SANY,   TANY,
 
579
                0,     0,
 
580
                "       jsri.a [AL]\nZB", },
 
581
 
 
582
    
 
583
{ FREE, FREE,   FREE,   FREE,   FREE,   FREE,   FREE,   FREE,   "help; I'm in trouble\n" },
 
584
};
 
585
 
 
586
int tablesize = sizeof(table)/sizeof(table[0]);
 
587