Various small fixes and additions to the 680x0 parts:
[rmac] / 6502.c
1 //
2 // RMAC - Reboot's Macro Assembler for all Atari computers
3 // 6502.C - 6502 Assembler
4 // Copyright (C) 199x Landon Dyer, 2011-2017 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 //    Init6502  initialization
9 //    d_6502    handle ".6502" directive
10 //    m6502cg   generate code for a 6502 mnemonic
11 //    d_org     handle 6502 section's ".org" directive
12 //    m6502obj  generate 6502 object file
13 //
14 #include "direct.h"
15 #include "expr.h"
16 #include "error.h"
17 #include "mach.h"
18 #include "procln.h"
19 #include "riscasm.h"
20 #include "rmac.h"
21 #include "sect.h"
22 #include "token.h"
23
24 #define UPSEG_SIZE      0x10010L // size of 6502 code buffer, 64K+16bytes
25
26 // Internal vars
27 static uint16_t orgmap[1024][2];                // Mark all 6502 org changes
28
29 // Exported vars
30 const char in_6502mode[] = "directive illegal in .6502 section";
31 uint16_t * currentorg = &orgmap[0][0];  // Current org range
32 char strtoa8[128];      // ASCII to Atari 800 internal conversion table
33
34 //
35 // 6502 addressing modes;
36 // DO NOT CHANGE THESE VALUES.
37 //
38 #define A65_ABS         0
39 #define A65_ABSX        1
40 #define A65_ABSY        2
41 #define A65_IMPL        3
42 #define A65_IMMED       4
43 #define A65_INDX        5
44 #define A65_INDY        6
45 #define A65_IND         7
46 #define A65_REL         8
47 #define A65_ZP          9
48 #define A65_ZPX         10
49 #define A65_ZPY         11
50 #define A65_IMMEDH  12
51 #define A65_IMMEDL  13
52
53 #define NMACHOPS 56             // Number of machine ops
54 #define NMODES  14              // Number of addressing modes
55 #define NOP     0xEA            // 6502 NOP instruction
56 #define ILLEGAL 0xFF    // 'Illegal instr' marker
57 #define END65   0xFF    // End-of-an-instr-list
58
59 static char imodes[] =
60 {
61         A65_IMMED, 0x69, A65_ABS, 0x6d, A65_ZP, 0x65, A65_INDX, 0x61, A65_INDY, 0x71,
62         A65_ZPX, 0x75, A65_ABSX, 0x7d, A65_ABSY, 0x79, END65,
63         A65_IMMED, 0x29, A65_ABS, 0x2d, A65_ZP, 0x25, A65_INDX, 0x21, A65_INDY, 0x31,
64         A65_ZPX, 0x35, A65_ABSX, 0x3d, A65_ABSY, 0x39, END65,
65         A65_ABS, 0x0e, A65_ZP, 0x06, A65_IMPL, 0x0a, A65_ZPX, 0x16, A65_ABSX,
66         0x1e, END65,
67         A65_REL, 0x90, END65,
68         A65_REL, 0xb0, END65,
69         A65_REL, 0xf0, END65,
70         A65_REL, 0xd0, END65,
71         A65_REL, 0x30, END65,
72         A65_REL, 0x10, END65,
73         A65_REL, 0x50, END65,
74         A65_REL, 0x70, END65,
75         A65_ABS, 0x2c, A65_ZP, 0x24, END65,
76         A65_IMPL, 0x00, END65,
77         A65_IMPL, 0x18, END65,
78         A65_IMPL, 0xd8, END65,
79         A65_IMPL, 0x58, END65,
80         A65_IMPL, 0xb8, END65,
81         A65_IMMED, 0xc9, A65_ABS, 0xcd, A65_ZP, 0xc5, A65_INDX, 0xc1, A65_INDY, 0xd1,
82         A65_ZPX, 0xd5, A65_ABSX, 0xdd, A65_ABSY, 0xd9, END65,
83         A65_IMMED, 0xe0, A65_ABS, 0xec, A65_ZP, 0xe4, END65,
84         A65_IMMED, 0xc0, A65_ABS, 0xcc, A65_ZP, 0xc4, END65,
85         A65_ABS, 0xce, A65_ZP, 0xc6, A65_ZPX, 0xd6, A65_ABSX, 0xde, END65,
86         A65_IMPL, 0xca, END65,
87         A65_IMPL, 0x88, END65,
88         A65_IMMED, 0x49, A65_ABS, 0x4d, A65_ZP, 0x45, A65_INDX, 0x41, A65_INDY, 0x51,
89         A65_ZPX, 0x55, A65_ABSX, 0x5d, A65_ABSY, 0x59, END65,
90         A65_ABS, 0xee, A65_ZP, 0xe6, A65_ZPX, 0xf6, A65_ABSX, 0xfe, END65,
91         A65_IMPL, 0xe8, END65,
92         A65_IMPL, 0xc8, END65,
93         A65_ABS, 0x4c, A65_IND, 0x6c, END65,
94         A65_ABS, 0x20, END65,
95         A65_IMMED, 0xa9, A65_ABS, 0xad, A65_ZP, 0xa5, A65_INDX, 0xa1, A65_INDY, 0xb1,
96         A65_ZPX, 0xb5, A65_ABSX, 0xbd, A65_ABSY, 0xb9, A65_IMMEDH, 0xa9, A65_IMMEDL, 0xa9, END65,
97         A65_IMMED, 0xa2, A65_ABS, 0xae, A65_ZP, 0xa6, A65_ABSY, 0xbe,
98         A65_ZPY, 0xb6, A65_IMMEDH, 0xa2, A65_IMMEDL, 0xa2, END65,
99         A65_IMMED, 0xa0, A65_ABS, 0xac, A65_ZP, 0xa4, A65_ZPX, 0xb4,
100         A65_ABSX, 0xbc, A65_IMMEDH, 0xa0, A65_IMMEDL, 0xa0, END65,
101         A65_ABS, 0x4e, A65_ZP, 0x46, A65_IMPL, 0x4a, A65_ZPX, 0x56,
102         A65_ABSX, 0x5e, END65,
103         A65_IMPL, 0xea, END65,
104         A65_IMMED, 0x09, A65_ABS, 0x0d, A65_ZP, 0x05, A65_INDX, 0x01, A65_INDY, 0x11,
105         A65_ZPX, 0x15, A65_ABSX, 0x1d, A65_ABSY, 0x19, END65,
106         A65_IMPL, 0x48, END65,
107         A65_IMPL, 0x08, END65,
108         A65_IMPL, 0x68, END65,
109         A65_IMPL, 0x28, END65,
110         A65_ABS, 0x2e, A65_ZP, 0x26, A65_IMPL, 0x2a, A65_ZPX, 0x36,
111         A65_ABSX, 0x3e, END65,
112         A65_ABS, 0x6e, A65_ZP, 0x66, A65_IMPL, 0x6a, A65_ZPX, 0x76,
113         A65_ABSX, 0x7e, END65,
114         A65_IMPL, 0x40, END65,
115         A65_IMPL, 0x60, END65,
116         A65_IMMED, 0xe9, A65_ABS, 0xed, A65_ZP, 0xe5, A65_INDX, 0xe1, A65_INDY, 0xf1,
117         A65_ZPX, 0xf5, A65_ABSX, 0xfd, A65_ABSY, 0xf9, END65,
118         A65_IMPL, 0x38, END65,
119         A65_IMPL, 0xf8, END65,
120         A65_IMPL, 0x78, END65,
121         A65_ABS, 0x8d, A65_ZP, 0x85, A65_INDX, 0x81, A65_INDY, 0x91, A65_ZPX, 0x95,
122         A65_ABSX, 0x9d, A65_ABSY, 0x99, END65,
123         A65_ABS, 0x8e, A65_ZP, 0x86, A65_ZPY, 0x96, END65,
124         A65_ABS, 0x8c, A65_ZP, 0x84, A65_ZPX, 0x94, END65,
125         A65_IMPL, 0xaa, END65,
126         A65_IMPL, 0xa8, END65,
127         A65_IMPL, 0xba, END65,
128         A65_IMPL, 0x8a, END65,
129         A65_IMPL, 0x9a, END65,
130         A65_IMPL, 0x98, END65
131 };
132
133 static char ops[NMACHOPS][NMODES];                      // Opcodes
134 static unsigned char inf[NMACHOPS][NMODES];     // Construction info
135
136 // Absolute-to-zeropage translation table
137 static int abs2zp[] =
138 {
139         A65_ZP,         // ABS
140         A65_ZPX,        // ABSX
141         A65_ZPY,        // ABSY
142         -1,                     // IMPL
143         -1,                     // IMMED
144         -1,                     // INDX
145         -1,                     // INDY
146         -1,                     // IND
147         -1,                     // REL
148         -1,                     // ZP
149         -1,                     // ZPX
150         -1                      // ZPY
151 };
152
153 static char a8internal[] =
154 {
155     ' ', 0,   '!', 1,   '"', 2,   '#', 3,   '$',  4,   '%', 5,   '&', 6,   '\'', 7,
156     '(', 8,   ')', 9,   '*', 10,  '+', 11,  ',',  12,  '-', 13,  '.', 14,  '/',  15,
157     '0', 16,  '1', 17,  '2', 18,  '3', 19,  '4',  20,  '5', 21,  '6', 22,  '7',  23,
158     '8', 24,  '9', 25,  ':', 26,  ';', 27,  '<',  28,  '=', 29,  '>', 30,  '?',  31,
159     '@', 32,  'A', 33,  'B', 34,  'C', 35,  'D',  36,  'E', 37,  'F', 38,  'G',  39,
160     'H', 40,  'I', 41,  'J', 42,  'K', 43,  'L',  44,  'M', 45,  'N', 46,  'O',  47,
161     'P', 48,  'Q', 49,  'R', 50,  'S', 51,  'T',  52,  'U', 53,  'V', 54,  'W',  55,
162     'X', 56,  'Y', 57,  'Z', 58,  '[', 59,  '\\', 60,  ']', 61,  '^', 62,  '_',  63,
163     'a', 97,  'b', 98,  'c', 99,  'd', 100, 'e',  101, 'f', 102, 'g', 103, 'h',  104,
164     'i', 105, 'j', 106, 'k', 107, 'l', 108, 'm',  109, 'n', 110, 'o', 111, 'p',  112,
165     'q', 113, 'r', 114, 's', 115, 't', 116, 'u',  117, 'v', 118, 'w', 119, 'x',  120,
166     'y', 121, 'z', 122
167 };
168
169
170 //
171 // Initialize 6502 assembler
172 //
173 void Init6502()
174 {
175         register int i;
176         register int j;
177
178         register char * s = imodes;
179
180         // Set all instruction slots to illegal
181         for(i=0; i<NMACHOPS; i++)
182                 for(j=0; j<NMODES; j++)
183                         inf[i][j] = ILLEGAL;
184
185         // Uncompress legal instructions into their slots
186         for(i=0; i<NMACHOPS; i++)
187         {
188                 do
189                 {
190                         j = *s & 0xFF;
191                         inf[i][j] = *s;
192                         ops[i][j] = s[1];
193
194                         /* hack A65_REL mode */
195                         if (*s == A65_REL)
196                         {
197                                 inf[i][A65_ABS] = A65_REL;
198                                 ops[i][A65_ABS] = s[1];
199                                 inf[i][A65_ZP] = A65_REL;
200                                 ops[i][A65_ZP] = s[1];
201                         }
202                 }
203                 while (*(s += 2) != (char)END65);
204
205                 s++;
206         }
207
208         // Set up first org section (set to zero)
209         orgmap[0][0] = 0;
210
211         SwitchSection(M6502);   // Switch to 6502 section
212
213         // Initialise string conversion table(s)
214         char * p = a8internal;
215         memset(strtoa8, 31, 128);   // 31=fallback value ("?")
216
217         for(; p<a8internal+sizeof(a8internal); p+=2)
218                 strtoa8[p[0]] = p[1];
219
220         if (challoc == 0)
221         {
222                 // Allocate and clear 64K of space for the 6502 section
223                 chcheck(UPSEG_SIZE);
224                 memset(sect[M6502].scode->chptr, 0, UPSEG_SIZE);
225         }
226
227         SwitchSection(TEXT);    // Go back to TEXT
228 }
229
230
231 //
232 // .6502 --- enter 6502 mode
233 //
234 int d_6502()
235 {
236         SaveSection();                  // Save curent section
237         SwitchSection(M6502);   // Switch to 6502 section
238
239         return 0;
240 }
241
242
243 //
244 // Do 6502 code generation
245 //
246 void m6502cg(int op)
247 {
248         register int amode;             // (Parsed) addressing mode
249         register int i;
250         uint64_t eval;                  // Expression value
251         WORD eattr;                             // Expression attributes
252         int zpreq;                              // 1, optimize instr to zero-page form
253         register char * p;              // (Temp) string usage
254         ch_size = 0;                    // Reset chunk size on every instruction
255
256         //
257         // Parse 6502 addressing mode
258         //
259         zpreq = 0;
260
261         switch (tok[0])
262         {
263         case EOL:
264                 amode = A65_IMPL;
265                 break;
266
267         case '#':
268                 tok++;
269
270                 if (*tok == '>')
271                 {
272                         tok++;
273
274                         if (expr(exprbuf, &eval, &eattr, NULL) < 0)
275                                 return;
276
277                         amode = A65_IMMEDH;
278                         break;
279                 }
280                 else if (*tok == '<')
281                 {
282                         tok++;
283
284                         if (expr(exprbuf, &eval, &eattr, NULL) < 0)
285                                 return;
286
287                         amode = A65_IMMEDL;
288                         break;
289                 }
290
291                 if (expr(exprbuf, &eval, &eattr, NULL) < 0)
292                         return;
293
294                 amode = A65_IMMED;
295                 break;
296
297         case '(':
298                 tok++;
299
300                 if (expr(exprbuf, &eval, &eattr, NULL) < 0)
301                         return;
302
303                 if (*tok == ')')
304                 {
305                         // (foo) or (foo),y
306                         if (*++tok == ',')
307                         {
308                                 // (foo),y
309                                 tok++;
310                                 p = string[tok[1]];
311
312                                 // Sleazo tolower() -----------------vvvvvvvvvvv
313                                 if (*tok != SYMBOL || p[1] != EOS || (*p | 0x20) != 'y')
314                                         goto badmode;
315
316                                 tok += 2;
317                                 amode = A65_INDY;
318                         }
319                         else
320                                 amode = A65_IND;
321                 }
322                 else if (*tok == ',')
323                 {
324                         // (foo,x)
325                         tok++;
326                         p = string[tok[1]];
327
328                         // Sleazo tolower() -----------------vvvvvvvvvvv
329                         if (*tok != SYMBOL || p[1] != EOS || (*p | 0x20) != 'x')
330                                 goto badmode;
331
332                         tok += 2;
333
334                         if (*tok++ != ')')
335                                 goto badmode;
336
337                         amode = A65_INDX;
338                 }
339                 else
340                         goto badmode;
341
342                 break;
343
344         case '@':
345                 tok++;
346
347                 if (expr(exprbuf, &eval, &eattr, NULL) < 0)
348                         return;
349
350                 if (*tok == '(')
351                 {
352                         tok++;
353                         p = string[tok[1]];
354
355                         if (*tok != SYMBOL || p[1] != EOS || tok[2] != ')' || tok[3] != EOL)
356                                 goto badmode;
357
358                         i = (*p | 0x20);        // Sleazo tolower()
359
360                         if (i == 'x')
361                                 amode = A65_INDX;
362                         else if (i == 'y')
363                                 amode = A65_INDY;
364                         else
365                                 goto badmode;
366
367                         tok += 3;               // Past SYMBOL <string> ')' EOL
368                         zpreq = 1;              // Request zeropage optimization
369                 }
370                 else if (*tok == EOL)
371                         amode = A65_IND;
372                 else
373                         goto badmode;
374
375                 break;
376
377         default:
378                 //
379                 // Short-circuit
380                 //   x,foo
381                 //   y,foo
382                 //
383                 p = string[tok[1]];
384                 // ggn: the following code is effectively disabled as it would make
385                 //      single letter labels not work correctly (would not identify the
386                 //      label properly). And from what I understand it's something to
387                 //      keep compatibility with the coinop assembler which is probably
388                 //      something we don't care about much :D
389 #if 0
390                 if (*tok == SYMBOL && p[1] == EOS && tok[2] == ',')
391                 {
392                         tok += 3;               // Past: SYMBOL <string> ','
393                         i = (*p | 0x20);
394
395                         if (i == 'x')
396                                 amode = A65_ABSX;
397                         else if (i == 'y')
398                                 amode = A65_ABSY;
399                         else
400                                 goto not_coinop;
401
402                         if (expr(exprbuf, &eval, &eattr, NULL) < 0)
403                                 return;
404
405                         if (*tok != EOL)
406                                 goto badmode;
407
408                         zpreq = 1;
409                         break;
410                 }
411
412 not_coinop:
413 #endif
414                 if (expr(exprbuf, &eval, &eattr, NULL) < 0)
415                         return;
416
417                 zpreq = 1;
418
419                 if (*tok == EOL)
420                         amode = A65_ABS;
421                 else if (*tok == ',')
422                 {
423                         tok++;
424                         p = string[tok[1]];
425
426                         if (*tok != SYMBOL || p[1] != EOS)
427                                 goto badmode;
428
429                         tok += 2;
430
431                         //
432                         // Check for X or Y index register;
433                         // the OR with 0x20 is a sleazo conversion
434                         // to lower-case that actually works.
435                         //
436                         i = *p | 0x20;  // Oooh, this is slimey (but fast!)
437
438                         if (i == 'x')
439                                 amode = A65_ABSX;
440                         else if (i == 'y')
441                                 amode = A65_ABSY;
442                         else
443                                 goto badmode;
444                 }
445                 else
446                         goto badmode;
447
448                 break;
449
450 badmode:
451                 error("bad 6502 addressing mode");
452                 return;
453         }
454
455         //
456         // Optimize ABS modes to zero-page when possible
457         //   o  ZPX or ZPY is illegal, or
458         //   o  expr is zeropage && zeropageRequest && expression is defined
459         //
460         if (inf[op][amode] == ILLEGAL   // If current op is illegal,
461                 || (eval < 0x100                        // or expr must be zero-page
462                 && zpreq != 0                           // amode must request zero-page opt.
463                 && (eattr & DEFINED)))          // and the expression must be defined
464         {
465                 i = abs2zp[amode];                      // i = zero-page translation of amode
466 #ifdef DO_DEBUG
467                 DEBUG printf(" OPT: op=%d amode=%d i=%d inf[op][i]=%d\n",
468                                          op, amode, i, inf[op][i]);
469 #endif
470                 if (i >= 0 && (inf[op][i] & 0xFF) != ILLEGAL) // Use it if it's legal
471                         amode = i;
472         }
473
474 #ifdef DO_DEBUG
475         DEBUG printf("6502: op=%d amode=%d ", op, amode);
476         DEBUG printf("inf[op][amode]=%d\n", (int)inf[op][amode]);
477 #endif
478
479         switch (inf[op][amode])
480         {
481                 case A65_IMPL:          // Just leave the instruction
482                         D_byte(ops[op][amode]);
483                         break;
484
485                 case A65_IMMEDH:
486                         D_byte(ops[op][amode]);
487
488                         if (!(eattr & DEFINED))
489                         {
490                                 AddFixup(FU_BYTEH, sloc, exprbuf);
491                                 eval = 0;
492                         }
493
494                         eval = (eval >> 8) & 0xFF; // Bring high byte to low
495                         D_byte(eval);                           // Deposit byte following instr
496                         break;
497
498                 case A65_IMMEDL:
499                         D_byte(ops[op][amode]);
500
501                         if (!(eattr & DEFINED))
502                         {
503                                 AddFixup(FU_BYTEL, sloc, exprbuf);
504                                 eval = 0;
505                         }
506
507                         eval = eval & 0xFF; // Mask high byte
508                         D_byte(eval);           // Deposit byte following instr
509                         break;
510
511                 case A65_IMMED:
512                 case A65_INDX:
513                 case A65_INDY:
514                 case A65_ZP:
515                 case A65_ZPX:
516                 case A65_ZPY:
517                         D_byte(ops[op][amode]);
518
519                         if (!(eattr & DEFINED))
520                         {
521                                 AddFixup(FU_BYTE, sloc, exprbuf);
522                                 eval = 0;
523                         }
524                         else if (eval + 0x100 >= 0x200)
525                         {
526                                 error(range_error);
527                                 eval = 0;
528                         }
529
530                         D_byte(eval);           // Deposit byte following instr
531                         break;
532
533                 case A65_REL:
534                         D_byte(ops[op][amode]);
535
536                         if (eattr & DEFINED)
537                         {
538                                 eval -= (sloc + 1);
539
540                                 if (eval + 0x80 >= 0x100)
541                                 {
542                                         error(range_error);
543                                         eval = 0;
544                                 }
545
546                                 D_byte(eval);
547                         }
548                         else
549                         {
550                                 AddFixup(FU_6BRA, sloc, exprbuf);
551                                 D_byte(0);
552                         }
553
554                         break;
555
556                 case A65_ABS:
557                 case A65_ABSX:
558                 case A65_ABSY:
559                 case A65_IND:
560                         D_byte(ops[op][amode]);
561
562                         if (!(eattr & DEFINED))
563                         {
564                                 AddFixup(FU_WORD, sloc, exprbuf);
565                                 eval = 0;
566                         }
567
568                         D_rword(eval);
569                         break;
570
571                         //
572                         // Deposit 3 NOPs for illegal things
573                         //
574                 default:
575                 case ILLEGAL:
576                         for(i=0; i<3; i++)
577                                 D_byte(NOP);
578
579                         error("illegal 6502 addressing mode");
580         }
581
582         // Check for overflow of code region
583         if (sloc > 0x10000L)
584                 fatal("6502 code pointer > 64K");
585
586         if (*tok != EOL)
587                 error(extra_stuff);
588 }
589
590
591 //
592 // Generate 6502 object output file.
593 //
594 // ggn: converted into a com/exe/xex output format
595 void m6502obj(int ofd)
596 {
597         uint16_t exeheader[3];
598         int headsize = 6;
599         uint16_t * headpoint = exeheader;
600
601         CHUNK * ch = sect[M6502].scode;
602
603         // If no 6502 code was generated, forget it
604         if ((ch == NULL) || (ch->challoc == 0))
605                 return;
606
607         exeheader[0] = 0xFFFF;          // Mandatory for first segment
608         register uint8_t * p = ch->chptr;
609
610         for(uint16_t * l=&orgmap[0][0]; l<currentorg; l+=2)
611         {
612                 exeheader[1] = l[0];
613                 exeheader[2] = l[1] - 1;
614
615                 // Write header
616                 size_t unused = write(ofd, headpoint, headsize);
617                 unused = write(ofd, p + l[0], l[1] - l[0]);
618
619                 // Skip the $FFFF after first segment, it's not mandatory
620                 headpoint = &exeheader[1];
621                 headsize = 4;
622         }
623 }
624