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