Various cleanups to fix compiler warnings.
[rmac] / mach.c
1 //
2 // RMAC - Reboot's Macro Assembler for the Atari Jaguar Console System
3 // MACH.C - Code Generation
4 // Copyright (C) 199x Landon Dyer, 2011 Reboot and Friends
5 // RMAC derived from MADMAC v1.07 Written by Landon Dyer, 1986
6 // Source Utilised with the Kind Permission of Landon Dyer
7 //
8
9 #include "mach.h"
10 #include "error.h"
11 #include "sect.h"
12 #include "direct.h"
13 #include "token.h"
14 #include "procln.h"
15 #include "risca.h"
16
17 #define DEF_KW
18 #include "kwtab.h"
19
20 // Common error messages
21 char * range_error = "expression out of range";
22 char * abs_error = "illegal absolute expression";
23 char * seg_error = "bad (section) expression";
24 char * rel_error = "illegal relative address";
25 char * siz_error = "bad size specified";
26 char * undef_error = "undefined expression";
27 char * fwd_error = "forward or undefined expression";
28
29 extern int ea0gen(WORD);
30 extern int ea1gen(WORD);
31
32 // Include code tables
33 MNTAB machtab[] = {
34    { (WORD)-1, (unsigned long)-1L, (unsigned long)-1L, 0x0000, 0, m_badmode }, // 0 
35    #include "68ktab.h"
36    {  0,  0L,  0L, 0x0000, 0, m_unimp   }                   // Last entry
37 };
38
39 // Register number << 9
40 WORD reg_9[8] = {
41       0, 1<<9, 2<<9, 3<<9,
42    4<<9, 5<<9, 6<<9, 7<<9
43 };
44
45 // SIZB==>00, SIZW==>01, SIZL==>10, SIZN==>01 << 6
46 WORD siz_6[] = {
47    (WORD)-1,                                                // n/a 
48    0,                                                       // SIZB
49    1<<6, (WORD)-1,                                          // SIZW, n/a 
50    2<<6, (WORD)-1, (WORD)-1, (WORD)-1,                      // SIZL, n/a, n/a, n/a 
51    1<<6                                                     // SIZN 
52 };
53
54 // Byte/word/long size for MOVE instrs
55 WORD siz_12[] = {
56    (WORD)-1,
57    0x1000,                                                  // Byte 
58    0x3000, (WORD)-1,                                        // Word 
59    0x2000, (WORD)-1, (WORD)-1, (WORD)-1,                    // Long
60    0x3000                                                   // Word (SIZN)
61 };
62
63 // Word/long size (0=.w, 1=.l) in bit 8
64 WORD lwsiz_8[] = {
65    (WORD)-1,                                                // n/a
66    (WORD)-1,                                                // SIZB
67    0, (WORD)-1,                                             // SIZW, n/a
68    1<<8, (WORD)-1, (WORD)-1, (WORD)-1,                      // SIZL, n/a, n/a, n/a
69    0                                                        // SIZN
70 };
71
72 // Addressing mode in bits 6..11 (register/mode fields are reversed)
73 WORD am_6[] = {
74    00000, 01000, 02000, 03000, 04000, 05000, 06000, 07000,
75    00100, 01100, 02100, 03100, 04100, 05100, 06100, 07100,
76    00200, 01200, 02200, 03200, 04200, 05200, 06200, 07200,
77    00300, 01300, 02300, 03300, 04300, 05300, 06300, 07300,
78    00400, 01400, 02400, 03400, 04400, 05400, 06400, 07400,
79    00500, 01500, 02500, 03500, 04500, 05500, 06500, 07500,
80    00600, 01600, 02600, 03600, 04600, 05600, 06600, 07600,
81    00700, 01700, 02700, 03700, 04700, 05700, 06700, 07700
82 };
83
84 // Error messages
85 int m_unimp(void) { return((int)error("unimplemented mnemonic")); }
86 int m_badmode(void) { return((int)error("inappropriate addressing mode")); }
87
88 int m_self(WORD inst) { D_word(inst); return(0);}
89
90 //
91 // -------------------------------------------------------------------------------------------------
92 // Do one EA in bits 0..5
93 // 
94 // Bits in `inst' have the following meaning:
95 // 
96 // Bit zero specifies which ea (ea0 or ea1) to generate in the lower six bits of the instr.
97 // 
98 // If bit one is set, the OTHER ea (the one that wasn't generated by bit zero) is generated after 
99 // the instruction.  Regardless of bit 0's value, ea0 is always deposited in memory before ea1.
100 // 
101 // If bit two is set, standard size bits are set in the instr in bits 6 and 7.
102 // 
103 // If bit four is set, bit three specifies which eaXreg to place in bits 9..11 of the instr.
104 // -------------------------------------------------------------------------------------------------
105 //
106
107 int m_ea(WORD inst, WORD siz) {
108    WORD flg;
109
110    flg = inst;                                              // Save flag bits 
111    inst &= ~0x3f;                                           // Clobber flag bits in instr 
112
113    if(flg & 4)                                              // Install "standard" instr size bits 
114       inst |= siz_6[siz];
115
116    if(flg & 16) {                                           // OR-in register number 
117       if(flg & 8) {
118          inst |= reg_9[a1reg];                              // ea1reg in bits 9..11 
119       } else {
120          inst |= reg_9[a0reg];                              // ea0reg in bits 9..11 
121       }
122    }
123
124    if(flg & 1) {                                            // Use am1 
125       inst |= am1 | a1reg;                                  // Get ea1 into instr 
126       D_word(inst);                                         // Deposit instr 
127       if(flg & 2)                                           // Generate ea0 if requested 
128          ea0gen(siz);
129       ea1gen(siz);                                          // Generate ea1 
130    } else {                                                 // Use am0 
131       inst |= am0 | a0reg;                                       // Get ea0 into instr 
132       D_word(inst);                                         // Deposit instr 
133       ea0gen(siz);                                          // Generate ea0 
134       if(flg & 2)                                           // Generate ea1 if requested 
135          ea1gen(siz);
136    }
137
138    return(0);
139 }
140
141 //
142 // --- Dx,Dy nnnnXXXnssnnnYYY If bit 0 of `inst' is set, install size bits in bits 6..7 ------------
143 //
144  
145 int m_abcd(WORD inst, WORD siz) {
146    if(inst & 1) {                                           // Install size bits 
147       --inst;
148       inst |= siz_6[siz];
149    }
150
151    inst |= a0reg | reg_9[a1reg];
152    D_word(inst);
153
154    return(0);
155 }
156
157 //
158 // --- {adda} ea,AREG ------------------------------------------------------------------------------
159 //
160  
161 int m_adda(WORD inst, WORD siz) {
162    inst |= am0 | a0reg | lwsiz_8[siz] | reg_9[a1reg];
163    D_word(inst);
164    ea0gen(siz);                                             // Gen EA 
165
166    return(0);
167 }
168
169 //
170 // -------------------------------------------------------------------------------------------------
171 // If bit 0 of `inst' is 1, install size bits in bits 6..7 of instr.
172 // If bit 1 of `inst' is 1, install a1reg in bits 9..11 of instr.
173 // -------------------------------------------------------------------------------------------------
174 // 
175
176 int m_reg(WORD inst, WORD siz) {
177    if(inst & 1)                                             // Install size bits 
178       inst |= siz_6[siz];
179    if(inst & 2)                                             // Install other register (9..11) 
180       inst |= reg_9[a1reg];
181
182    inst &= ~7;                                              // Clear off crufty bits 
183    inst |= a0reg;                                           // Install first register 
184    D_word(inst);
185
186    return(0);
187 }
188
189 //
190 // --- <op> #expr ----------------------------------------------------------------------------------
191 //
192  
193 int m_imm(WORD inst, WORD siz) {
194    D_word(inst);
195    ea0gen(siz);
196
197    return(0);
198 }
199
200 //
201 // --- <op>.b #expr --------------------------------------------------------------------------------
202 //
203  
204 int m_imm8(WORD inst, WORD siz) {
205    siz = siz;
206    D_word(inst);
207    ea0gen(SIZB);
208
209    return(0);
210 }
211
212 //
213 // --- <shift> Dn,Dn -------------------------------------------------------------------------------
214 //
215  
216 int m_shr(WORD inst, WORD siz) {
217    inst |= reg_9[a0reg] | a1reg | siz_6[siz];
218    D_word(inst);
219
220    return(0);
221 }
222
223 //
224 // --- <shift> #n,Dn -------------------------------------------------------------------------------
225 //
226  
227 int m_shi(WORD inst, WORD siz) {
228    inst |= a1reg | siz_6[siz];
229
230    if(a0exattr & DEFINED) {
231       if(a0exval > 8)
232          return(error(range_error));
233       inst |= (a0exval & 7) << 9;
234       D_word(inst);
235    } else {
236       fixup(FU_QUICK, sloc, a0expr);
237       D_word(inst);
238    }
239
240    return(0);
241 }
242
243 //
244 // --- {bset, btst, bchg, bclr} -- #immed,ea -- Dn,ea ----------------------------------------------
245 //
246  
247 int m_bitop(WORD inst, WORD siz) {
248    // Enforce instruction sizes
249    if(am1 == DREG) {                                        // X,Dn must be .n or .l 
250       if(siz & (SIZB|SIZW))
251          return(error(siz_error));
252    } else 
253       if(siz & (SIZW|SIZL))                                 // X,ea must be .n or .b 
254          return error(siz_error);
255
256    // Construct instr and EAs
257    inst |= am1 | a1reg;
258    if(am0 == IMMED) {
259       D_word(inst);
260       ea0gen(SIZB);                                         // Immediate bit number 
261    } else {
262       inst |= reg_9[a0reg];
263       D_word(inst);
264    }
265
266    ea1gen(SIZB);                                            // ea to bit-munch 
267
268    return(0);
269 }
270
271 int m_dbra(WORD inst, WORD siz) {
272    VALUE v;
273
274    siz = siz;
275    inst |= a0reg;
276    D_word(inst);
277    if(a1exattr & DEFINED) {
278       if((a1exattr & TDB) != cursect)
279          return(error(rel_error));
280       v = a1exval - sloc;
281
282       if(v + 0x8000 > 0x10000)
283          return(error(range_error));
284       D_word(v);
285    } else {
286       fixup(FU_WORD|FU_PCREL|FU_ISBRA, sloc, a1expr);
287       D_word(0);
288    }
289
290    return(0);
291 }
292
293 //
294 // --- EXG -----------------------------------------------------------------------------------------
295 //
296  
297 int m_exg(WORD inst, WORD siz) {
298    int m;
299
300    siz = siz;
301    if(am0 == DREG && am1 == DREG)
302       m = 0x0040;                                           // Dn,Dn 
303    else if(am0 == AREG && am1 == AREG)
304       m = 0x0048;                                           // An,An 
305    else {
306       if(am0 == AREG) {                                     // Dn,An or An,Dn 
307          m = a1reg;                                         // Get AREG into a1reg 
308          a1reg = a0reg;
309          a0reg = m;
310       }
311       m = 0x0088;
312    }
313    inst |= m | reg_9[a0reg] | a1reg;
314    D_word(inst);
315
316    return(0);
317 }
318
319 //
320 // --- LINK ----------------------------------------------------------------------------------------
321 //
322  
323 int m_link(WORD inst, WORD siz) {
324    siz = siz;
325    inst |= a0reg;
326    D_word(inst);
327    ea1gen(SIZW);
328
329    return(0);
330 }
331
332 //
333 // -------------------------------------------------------------------------------------------------
334 // Handle MOVE <C_ALL> <C_ALTDATA>
335 //        MOVE <C_ALL> <M_AREG>
336 // 
337 // Optimize MOVE.L #<smalldata>,D0 to a MOVEQ
338 // -------------------------------------------------------------------------------------------------
339 //
340  
341 int m_move(WORD inst, int siz) {
342    // Try to optimize to MOVEQ
343    if(siz == SIZL && am0 == IMMED && am1 == DREG && (a0exattr & (TDB|DEFINED)) == DEFINED &&
344       a0exval + 0x80 < 0x100) {
345       m_moveq((WORD)0x7000, (WORD)0);
346    } else {
347       inst |= siz_12[siz] | am_6[am1] | reg_9[a1reg] | am0 | a0reg;
348
349       D_word(inst);
350       if(am0 >= ADISP) ea0gen((WORD)siz);
351       if(am1 >= ADISP) ea1gen((WORD)siz);
352    }
353
354    return(0);
355 }
356
357 //
358 // --- move USP,An -- move An,USP ------------------------------------------------------------------
359 //
360  
361 int m_usp(WORD inst, WORD siz) {
362    siz = siz;
363    if(am0 == AM_USP) inst |= a1reg;                         // USP,An 
364    else inst |= a0reg;                                      // An,USP 
365    D_word(inst);
366
367    return(0);
368 }
369
370 //
371 // --- moveq ---------------------------------------------------------------------------------------
372 //
373  
374 int m_moveq(WORD inst, WORD siz) {
375    siz = siz;
376    if(!(a0exattr & DEFINED)) {                              // Arrange for future fixup 
377       fixup(FU_BYTE|FU_SEXT, sloc+1, a0expr);
378       a0exval = 0; 
379    } else 
380       if(a0exval + 0x100 >= 0x200)
381          return(error(range_error));
382
383    inst |= reg_9[a1reg] | (a0exval & 0xff);
384    D_word(inst);
385
386    return(0);
387 }
388
389 //
390 // --- movep Dn,disp(An) -- movep disp(An),Dn ------------------------------------------------------
391 //
392  
393 int m_movep(WORD inst, WORD siz) {
394    //WORD k;
395
396    if(siz == SIZL)
397       inst |= 0x0040;
398
399    if(am0 == DREG) {
400       inst |= reg_9[a0reg] | a1reg;
401       D_word(inst);
402       if(am1 == AIND) {
403          D_word(0);
404       } else 
405          ea1gen(siz);
406    } else {
407       inst |= reg_9[a1reg] | a0reg;
408       D_word(inst);
409       if(am0 == AIND) {
410          D_word(0);
411       } else 
412          ea0gen(siz);
413    }
414
415    return(0);
416 }
417
418 //
419 // --- Bcc -- BSR ----------------------------------------------------------------------------------
420 //
421  
422 int m_br(WORD inst, WORD siz) {
423    VALUE v;
424
425    if(a0exattr & DEFINED) {
426       if((a0exattr & TDB) != cursect)
427          return(error(rel_error));
428
429       v = a0exval - (sloc + 2);
430
431       // Optimize branch instr. size
432       if(siz == SIZN) {
433          if(v != 0 && v + 0x80 < 0x100) {                   // Fits in .B 
434             inst |= v & 0xff;
435             D_word(inst);
436             return(0);
437          } else {                                           // Fits in .W 
438             if(v + 0x8000 > 0x10000)
439                return(error(range_error));
440             D_word(inst);
441             D_word(v);
442             return(0);
443          }
444       }
445
446       if(siz == SIZB) {
447          if(v + 0x80 >= 0x100)
448             return(error(range_error));
449          inst |= v & 0xff;
450          D_word(inst);
451       } else {
452          if(v + 0x8000 >= 0x10000)
453             return(error(range_error));
454          D_word(inst);
455          D_word(v);
456       }
457       return(0);
458    } else 
459       if(siz == SIZN)
460          siz = SIZW;
461
462    if(siz == SIZB) {                                        // .B 
463       fixup(FU_BBRA|FU_PCREL|FU_SEXT, sloc, a0expr);
464       D_word(inst);
465       return(0);
466    } else {                                                 // .W 
467       D_word(inst);
468       fixup(FU_WORD|FU_PCREL|FU_LBRA|FU_ISBRA, sloc, a0expr);
469       D_word(0);
470    }
471
472    return(0);
473 }
474
475 //
476 // --- ADDQ -- SUBQ --------------------------------------------------------------------------------
477 //
478  
479 int m_addq(WORD inst, WORD siz) {
480    inst |= siz_6[siz] | am1 | a1reg;
481
482    if(a0exattr & DEFINED) {
483       if(a0exval > 8 || a0exval == 0)                       // Range in 1..8 
484          return(error(range_error));
485       inst |= (a0exval & 7) << 9;
486       D_word(inst);
487    } else {
488       fixup(FU_QUICK, sloc, a0expr);
489       D_word(inst);
490    }
491    ea1gen(siz);
492
493    return(0);
494 }
495
496 //
497 // --- trap #n -------------------------------------------------------------------------------------
498 //
499  
500 int m_trap(WORD inst, WORD siz) {
501    siz = siz;
502    if(a0exattr & DEFINED) {
503       if(a0exattr & TDB)
504          return(error(abs_error));
505       if(a0exval >= 16)
506          return(error(range_error));
507       inst |= a0exval;
508       D_word(inst);
509    } else 
510       return(error(undef_error));
511
512    return(0);
513 }
514
515 //
516 // --- movem <rlist>,ea -- movem ea,<rlist> --------------------------------------------------------
517 //
518  
519 int m_movem(WORD inst, WORD siz) {
520    VALUE eval;
521    WORD i;
522    WORD w;
523    WORD rmask;
524
525    if(siz & SIZB) return(error("bad size suffix"));
526
527    if(siz == SIZL) inst |= 0x0040;
528
529    if(*tok == '#') {                                        // Handle #<expr>,ea 
530       ++tok;
531       if(abs_expr(&eval) != OK) return(0);
532       if(eval >= 0x10000L) return(error(range_error));
533       rmask = (WORD)eval;
534       goto immed1;
535    }
536
537    if(*tok >= KW_D0 && *tok <= KW_A7) {                     // <rlist>,ea 
538       if(reglist(&rmask) < 0) return(0);
539
540       immed1:
541
542       if(*tok++ != ',') return(error("missing comma"));
543       if(amode(0) < 0) return(0);
544       inst |= am0 | a0reg;
545
546       if(!(amsktab[am0] & (C_ALTCTRL|M_APREDEC)))
547          return(error("invalid addressing mode"));
548
549       // If APREDEC, reverse register mask
550       if(am0 == APREDEC) {
551          w = rmask;
552          rmask = 0;
553          for(i = 0x8000; i; i >>= 1, w >>= 1)
554             rmask = (WORD)((rmask << 1) | w & 1);
555       }
556    } else {                                                 // ea,<rlist> 
557       if(amode(0) < 0) return(0);
558       inst |= 0x0400 | am0 | a0reg;
559       if(*tok++ != ',') return(error("missing comma"));
560       if(*tok == EOL) return(error("missing register list"));
561
562       if(*tok == '#') {                                     // ea,#<expr> 
563          ++tok;
564          if(abs_expr(&eval) != OK) return(0);
565          if(eval >= 0x10000) return(error(range_error));
566          rmask = (WORD)eval;
567       } else 
568          if(reglist(&rmask) < 0) return(0);
569
570       if(!(amsktab[am0] & (C_CTRL|M_APOSTINC)))
571          return(error("invalid addressing mode"));
572    }
573
574    D_word(inst);
575    D_word(rmask);
576    ea0gen(siz);
577
578    return(0);
579 }
580
581 //
582 // --- CLR.x An ==> SUBA.x An,An -------------------------------------------------------------------
583 //
584  
585 int m_clra(WORD inst, WORD siz) {
586    inst |= a0reg | reg_9[a0reg] | lwsiz_8[siz];
587    D_word(inst);
588
589    return(0);
590 }
591