Shamusworld >> Repos - rmac/blob - 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         VALUE 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 ((int)*tok)
 262         {
 263         case EOL:
 264                 amode = A65_IMPL;
 265                 break;
 266
 267         case '#':
 268                 tok++;
 269
 270                 if (*tok == '>')
 271                 {
 272                         tok++;
 273                         if (expr(exprbuf, &eval, &eattr, NULL) < 0)
 274                                 return;
 275
 276                         amode = A65_IMMEDH;
 277                         break;
 278                 }
 279                 else if (*tok == '<')
 280                 {
 281                         tok++;
 282                         if (expr(exprbuf, &eval, &eattr, NULL) < 0)
 283                                 return;
 284
 285                         amode = A65_IMMEDL;
 286                         break;
 287                 }
 288
 289                 if (expr(exprbuf, &eval, &eattr, NULL) < 0)
 290                         return;
 291
 292                 amode = A65_IMMED;
 293                 break;
 294
 295         case '(':
 296                 tok++;
 297
 298                 if (expr(exprbuf, &eval, &eattr, NULL) < 0)
 299                         return;
 300
 301                 if (*tok == ')')
 302                 {
 303                         // (foo) or (foo),y
 304                         if (*++tok == ',')
 305                         {
 306                                 // (foo),y
 307                                 tok++;
 308                                 p = string[tok[1]];
 309
 310                                 if (*tok != SYMBOL || p[1] != EOS || (*p | 0x20) != 'y') // Sleazo tolower()
 311                                         goto badmode;
 312
 313                                 tok += 2;
 314                                 amode = A65_INDY;
 315                         }
 316                         else
 317                                 amode = A65_IND;
 318                 }
 319                 else if (*tok == ',')
 320                 {
 321                         // (foo,x)
 322                         tok++;
 323                         p = string[tok[1]];
 324
 325                         if (*tok != SYMBOL || p[1] != EOS || (*p | 0x20) != 'x') // Sleazo tolower()
 326                                 goto badmode;
 327
 328                         tok += 2;
 329
 330                         if (*tok++ != ')')
 331                                 goto badmode;
 332
 333                         amode = A65_INDX;
 334                 }
 335                 else
 336                         goto badmode;
 337
 338                 break;
 339
 340         case '@':
 341                 tok++;
 342
 343                 if (expr(exprbuf, &eval, &eattr, NULL) < 0)
 344                         return;
 345
 346                 if (*tok == '(')
 347                 {
 348                         tok++;
 349                         p = string[tok[1]];
 350
 351                         if (*tok != SYMBOL || p[1] != EOS || tok[2] != ')' || tok[3] != EOL)
 352                                 goto badmode;
 353
 354                         i = (*p | 0x20);        // Sleazo tolower()
 355
 356                         if (i == 'x')
 357                                 amode = A65_INDX;
 358                         else if (i == 'y')
 359                                 amode = A65_INDY;
 360                         else
 361                                 goto badmode;
 362
 363                         tok += 3;               // Past SYMBOL <string> ')' EOL
 364                         zpreq = 1;              // Request zeropage optimization
 365                 }
 366                 else if (*tok == EOL)
 367                         amode = A65_IND;
 368                 else
 369                         goto badmode;
 370
 371                 break;
 372
 373         default:
 374                 //
 375                 // Short-circuit
 376                 //   x,foo
 377                 //   y,foo
 378                 //
 379                 p = string[tok[1]];
 380                 // ggn: the following code is effectively disabled as it would make
 381                 //      single letter labels not work correctly (would not identify the
 382                 //      label properly). And from what I understand it's something to
 383                 //      keep compatibility with the coinop assembler which is probably
 384                 //      something we don't care about much :D
 385 #if 0
 386                 if (*tok == SYMBOL && p[1] == EOS && tok[2] == ',')
 387                 {
 388                         tok += 3;               // Past: SYMBOL <string> ','
 389                         i = (*p | 0x20);
 390
 391                         if (i == 'x')
 392                                 amode = A65_ABSX;
 393                         else if (i == 'y')
 394                                 amode = A65_ABSY;
 395                         else
 396                                 goto not_coinop;
 397
 398                         if (expr(exprbuf, &eval, &eattr, NULL) < 0)
 399                                 return;
 400
 401                         if (*tok != EOL)
 402                                 goto badmode;
 403
 404                         zpreq = 1;
 405                         break;
 406                 }
 407
 408 not_coinop:
 409 #endif
 410                 if (expr(exprbuf, &eval, &eattr, NULL) < 0)
 411                         return;
 412
 413                 zpreq = 1;
 414
 415                 if (*tok == EOL)
 416                         amode = A65_ABS;
 417                 else if (*tok == ',')
 418                 {
 419                         tok++;
 420                         p = string[tok[1]];
 421
 422                         if (*tok != SYMBOL || p[1] != EOS)
 423                                 goto badmode;
 424
 425                         tok += 2;
 426
 427                         //
 428                         // Check for X or Y index register;
 429                         // the OR with 0x20 is a sleazo conversion
 430                         // to lower-case that actually works.
 431                         //
 432                         i = *p | 0x20;  // Oooh, this is slimey (but fast!)
 433
 434                         if (i == 'x')
 435                                 amode = A65_ABSX;
 436                         else if (i == 'y')
 437                                 amode = A65_ABSY;
 438                         else
 439                                 goto badmode;
 440                 }
 441                 else
 442                         goto badmode;
 443
 444                 break;
 445
 446 badmode:
 447                 error("bad 6502 addressing mode");
 448                 return;
 449         }
 450
 451         //
 452         // Optimize ABS modes to zero-page when possible
 453         //   o  ZPX or ZPY is illegal, or
 454         //   o  expr is zeropage && zeropageRequest && expression is defined
 455         //
 456         if (inf[op][amode] == ILLEGAL   // If current op is illegal,
 457                 || (eval < 0x100                        // or expr must be zero-page
 458                 && zpreq != 0                           // amode must request zero-page opt.
 459                 && (eattr & DEFINED)))          // and the expression must be defined
 460         {
 461                 i = abs2zp[amode];                      // i = zero-page translation of amode
 462 #ifdef DO_DEBUG
 463                 DEBUG printf(" OPT: op=%d amode=%d i=%d inf[op][i]=%d\n",
 464                                          op, amode, i, inf[op][i]);
 465 #endif
 466                 if (i >= 0 && (inf[op][i] & 0xFF) != ILLEGAL) // Use it if it's legal
 467                         amode = i;
 468         }
 469
 470 #ifdef DO_DEBUG
 471         DEBUG printf("6502: op=%d amode=%d ", op, amode);
 472         DEBUG printf("inf[op][amode]=%d\n", (int)inf[op][amode]);
 473 #endif
 474
 475         switch (inf[op][amode])
 476         {
 477                 case A65_IMPL:          // Just leave the instruction
 478                         D_byte(ops[op][amode]);
 479                         break;
 480
 481                 case A65_IMMEDH:
 482                         D_byte(ops[op][amode]);
 483
 484                         if (!(eattr & DEFINED))
 485                         {
 486                                 AddFixup(FU_BYTEH, sloc, exprbuf);
 487                                 eval = 0;
 488                         }
 489
 490                         eval = (eval >> 8) & 0xFF; // Bring high byte to low
 491                         D_byte(eval);                           // Deposit byte following instr
 492                         break;
 493
 494                 case A65_IMMEDL:
 495                         D_byte(ops[op][amode]);
 496
 497                         if (!(eattr & DEFINED))
 498                         {
 499                                 AddFixup(FU_BYTEL, sloc, exprbuf);
 500                                 eval = 0;
 501                         }
 502
 503                         eval = eval & 0xFF; // Mask high byte
 504                         D_byte(eval);           // Deposit byte following instr
 505                         break;
 506
 507                 case A65_IMMED:
 508                 case A65_INDX:
 509                 case A65_INDY:
 510                 case A65_ZP:
 511                 case A65_ZPX:
 512                 case A65_ZPY:
 513                         D_byte(ops[op][amode]);
 514
 515                         if (!(eattr & DEFINED))
 516                         {
 517                                 AddFixup(FU_BYTE, sloc, exprbuf);
 518                                 eval = 0;
 519                         }
 520                         else if (eval + 0x100 >= 0x200)
 521                         {
 522                                 error(range_error);
 523                                 eval = 0;
 524                         }
 525
 526                         D_byte(eval);           // Deposit byte following instr
 527                         break;
 528
 529                 case A65_REL:
 530                         D_byte(ops[op][amode]);
 531
 532                         if (eattr & DEFINED)
 533                         {
 534                                 eval -= (sloc + 1);
 535
 536                                 if (eval + 0x80 >= 0x100)
 537                                 {
 538                                         error(range_error);
 539                                         eval = 0;
 540                                 }
 541
 542                                 D_byte(eval);
 543                         }
 544                         else
 545                         {
 546                                 AddFixup(FU_6BRA, sloc, exprbuf);
 547                                 D_byte(0);
 548                         }
 549
 550                         break;
 551
 552                 case A65_ABS:
 553                 case A65_ABSX:
 554                 case A65_ABSY:
 555                 case A65_IND:
 556                         D_byte(ops[op][amode]);
 557
 558                         if (!(eattr & DEFINED))
 559                         {
 560                                 AddFixup(FU_WORD, sloc, exprbuf);
 561                                 eval = 0;
 562                         }
 563
 564                         D_rword(eval);
 565                         break;
 566
 567                         //
 568                         // Deposit 3 NOPs for illegal things
 569                         //
 570                 default:
 571                 case ILLEGAL:
 572                         for(i=0; i<3; i++)
 573                                 D_byte(NOP);
 574
 575                         error("illegal 6502 addressing mode");
 576         }
 577
 578         // Check for overflow of code region
 579         if (sloc > 0x10000L)
 580                 fatal("6502 code pointer > 64K");
 581
 582         if (*tok != EOL)
 583                 error(extra_stuff);
 584 }
 585
 586
 587 //
 588 // Generate 6502 object output file.
 589 //
 590 // ggn: converted into a com/exe/xex output format
 591 void m6502obj(int ofd)
 592 {
 593         uint16_t exeheader[3];
 594         int headsize = 6;
 595         uint16_t * headpoint = exeheader;
 596
 597         CHUNK * ch = sect[M6502].scode;
 598
 599         // If no 6502 code was generated, forget it
 600         if ((ch == NULL) || (ch->challoc == 0))
 601                 return;
 602
 603         exeheader[0] = 0xFFFF;          // Mandatory for first segment
 604         register uint8_t * p = ch->chptr;
 605
 606         for(uint16_t * l=&orgmap[0][0]; l<currentorg; l+=2)
 607         {
 608                 exeheader[1] = l[0];
 609                 exeheader[2] = l[1] - 1;
 610
 611                 // Write header
 612                 size_t unused = write(ofd, headpoint, headsize);
 613                 unused = write(ofd, p + l[0], l[1] - l[0]);
 614
 615                 // Skip the $FFFF after first segment, it's not mandatory
 616                 headpoint = &exeheader[1];
 617                 headsize = 4;
 618         }
 619 }
 620