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