Shamusworld >> Repos - rmac/blob - sect.c

   1 //
   2 // RMAC - Reboot's Macro Assembler for all Atari computers
   3 // SECT.C - Code Generation, Fixups and Section Management
   4 // Copyright (C) 199x Landon Dyer, 2011-2019 Reboot and Friends
   5 // RMAC derived from MADMAC v1.07 Written by Landon Dyer, 1986
   6 // Source utilised with the kind permission of Landon Dyer
   7 //
   8
   9 #include "sect.h"
  10 #include "6502.h"
  11 #include "direct.h"
  12 #include "error.h"
  13 #include "expr.h"
  14 #include "listing.h"
  15 #include "mach.h"
  16 #include "mark.h"
  17 #include "riscasm.h"
  18 #include "symbol.h"
  19 #include "token.h"
  20
  21
  22 // Function prototypes
  23 void MakeSection(int, uint16_t);
  24 void SwitchSection(int);
  25
  26 // Section descriptors
  27 SECT sect[NSECTS];              // All sections...
  28 int cursect;                    // Current section number
  29
  30 // These are copied from the section descriptor, the current code chunk
  31 // descriptor and the current fixup chunk descriptor when a switch is made into
  32 // a section. They are copied back to the descriptors when the section is left.
  33 uint16_t scattr;                // Section attributes
  34 uint32_t sloc;                  // Current loc in section
  35
  36 CHUNK * scode;                  // Current (last) code chunk
  37 uint32_t challoc;               // # bytes alloc'd to code chunk
  38 uint32_t ch_size;               // # bytes used in code chunk
  39 uint8_t * chptr;                // Deposit point in code chunk buffer
  40 uint8_t * chptr_opcode; // Backup of chptr, updated before entering code generators
  41
  42 // Return a size (SIZB, SIZW, SIZL) or 0, depending on what kind of fixup is
  43 // associated with a location.
  44 static uint8_t fusiztab[] = {
  45         0,      // FU_QUICK
  46         1,      // FU_BYTE
  47         2,      // FU_WORD
  48         2,      // FU_WBYTE
  49         4,      // FU_LONG
  50         1,      // FU_BBRA
  51         0,      // (unused)
  52         1,      // FU_6BRA
  53 };
  54
  55 // Offset to REAL fixup location
  56 static uint8_t fusizoffs[] = {
  57         0,      // FU_QUICK
  58         0,      // FU_BYTE
  59         0,      // FU_WORD
  60         1,      // FU_WBYTE
  61         0,      // FU_LONG
  62         1,      // FU_BBRA
  63         0,      // (unused)
  64         0,      // FU_6BRA
  65 };
  66
  67
  68 //
  69 // Initialize sections; setup initial ABS, TEXT, DATA and BSS sections
  70 //
  71 void InitSection(void)
  72 {
  73         // Initialize all sections
  74         for(int i=0; i<NSECTS; i++)
  75                 MakeSection(i, 0);
  76
  77         // Construct default sections, make TEXT the current section
  78         MakeSection(ABS,   SUSED | SABS | SBSS);        // ABS
  79         MakeSection(TEXT,  SUSED | TEXT       );        // TEXT
  80         MakeSection(DATA,  SUSED | DATA       );        // DATA
  81         MakeSection(BSS,   SUSED | BSS  | SBSS);        // BSS
  82         MakeSection(M6502, SUSED | TEXT       );        // 6502 code section
  83
  84         // Switch to TEXT for starters
  85         SwitchSection(TEXT);
  86 }
  87
  88
  89 //
  90 // Make a new (clean) section
  91 //
  92 void MakeSection(int sno, uint16_t attr)
  93 {
  94         SECT * sp = &sect[sno];
  95         sp->scattr = attr;
  96         sp->sloc = 0;
  97         sp->orgaddr = 0;
  98         sp->scode = sp->sfcode = NULL;
  99         sp->sfix = sp->sffix = NULL;
 100 }
 101
 102
 103 //
 104 // Switch to another section (copy section & chunk descriptors to global vars
 105 // for fast access)
 106 //
 107 void SwitchSection(int sno)
 108 {
 109         CHUNK * cp;
 110         cursect = sno;
 111         SECT * sp = &sect[sno];
 112
 113         m6502 = (sno == M6502); // Set 6502-mode flag
 114
 115         // Copy section vars
 116         scattr = sp->scattr;
 117         sloc = sp->sloc;
 118         scode = sp->scode;
 119         orgaddr = sp->orgaddr;
 120
 121         // Copy code chunk vars
 122         if ((cp = scode) != NULL)
 123         {
 124                 challoc = cp->challoc;
 125                 ch_size = cp->ch_size;
 126                 chptr = cp->chptr + ch_size;
 127
 128                 // For 6502 mode, add the last org'd address
 129 // Why?
 130 /*
 131 Because the way this is set up it treats the 6502 assembly space as a single 64K space (+ 16 bytes, for some reason) and just bobbles around inside that space and uses a stack of org "pointers" to show where the data ended up.
 132
 133 This is a piss poor way to handle things, and for fucks sake, we can do better than this!
 134 */
 135                 if (m6502)
 136                         chptr = cp->chptr + orgaddr;
 137         }
 138         else
 139                 challoc = ch_size = 0;
 140 }
 141
 142
 143 //
 144 // Save current section
 145 //
 146 void SaveSection(void)
 147 {
 148         SECT * sp = &sect[cursect];
 149
 150         sp->scattr = scattr;                    // Bailout section vars
 151         sp->sloc = sloc;
 152         sp->orgaddr = orgaddr;
 153
 154         if (scode != NULL)                              // Bailout code chunk
 155                 scode->ch_size = ch_size;
 156 }
 157
 158
 159 //
 160 // Test to see if a location has a fixup set on it. This is used by the
 161 // listing generator to print 'xx's instead of '00's for forward references
 162 //
 163 int fixtest(int sno, uint32_t loc)
 164 {
 165         // Force update to sect[] variables
 166         StopMark();
 167
 168         // Ugly linear search for a mark on our location. The speed doesn't
 169         // matter, since this is only done when generating a listing, which is
 170         // SLOW anyway.
 171         for(FIXUP * fp=sect[sno].sffix; fp!=NULL; fp=fp->next)
 172         {
 173                 uint32_t w = fp->attr;
 174                 uint32_t xloc = fp->loc + (int)fusizoffs[w & FUMASK];
 175
 176                 if (xloc == loc)
 177                         return (int)fusiztab[w & FUMASK];
 178         }
 179
 180         return 0;
 181 }
 182
 183
 184 //
 185 // Check that there are at least 'amt' bytes left in the current chunk. If
 186 // there are not, allocate another chunk of at least CH_CODE_SIZE bytes or
 187 // 'amt', whichever is larger.
 188 //
 189 // If 'amt' is zero, ensure there are at least CH_THRESHOLD bytes, likewise.
 190 //
 191 void chcheck(uint32_t amt)
 192 {
 193         DEBUG { printf("chcheck(%u)\n", amt); }
 194
 195         // If in BSS section, no allocation required
 196         if (scattr & SBSS)
 197                 return;
 198
 199         if (amt == 0)
 200                 amt = CH_THRESHOLD;
 201
 202         DEBUG { printf("    challoc=%i, ch_size=%i, diff=%i\n", challoc, ch_size, challoc - ch_size); }
 203
 204         if ((int)(challoc - ch_size) >= (int)amt)
 205                 return;
 206
 207         if (amt < CH_CODE_SIZE)
 208                 amt = CH_CODE_SIZE;
 209
 210         DEBUG { printf("    amt (adjusted)=%u\n", amt); }
 211         SECT * p = &sect[cursect];
 212         CHUNK * cp = malloc(sizeof(CHUNK) + amt);
 213
 214         // First chunk in section
 215         if (scode == NULL)
 216         {
 217                 cp->chprev = NULL;
 218                 p->sfcode = cp;
 219         }
 220         // Add chunk to other chunks
 221         else
 222         {
 223                 cp->chprev = scode;
 224                 scode->chnext = cp;
 225                 scode->ch_size = ch_size;       // Save old chunk's globals
 226         }
 227
 228         // Setup chunk and global vars
 229         cp->chloc = sloc;
 230         cp->chnext = NULL;
 231         challoc = cp->challoc = amt;
 232         ch_size = cp->ch_size = 0;
 233         chptr = cp->chptr = ((uint8_t *)cp) + sizeof(CHUNK);
 234         scode = p->scode = cp;
 235
 236         return;
 237 }
 238
 239
 240 //
 241 // Arrange for a fixup on a location
 242 //
 243 int AddFixup(uint32_t attr, uint32_t loc, TOKEN * fexpr)
 244 {
 245         uint16_t exprlen = 0;
 246         SYM * symbol = NULL;
 247         uint32_t _orgaddr = 0;
 248
 249         // First, check to see if the expression is a bare label, otherwise, force
 250         // the FU_EXPR flag into the attributes and count the tokens.
 251         if ((fexpr[0] == SYMBOL) && (fexpr[2] == ENDEXPR))
 252         {
 253                 symbol = symbolPtr[fexpr[1]];
 254
 255                 // Save the org address for JR RISC instruction
 256                 if ((attr & FUMASKRISC) == FU_JR)
 257                         _orgaddr = orgaddr;
 258         }
 259         else
 260         {
 261                 attr |= FU_EXPR;
 262                 exprlen = ExpressionLength(fexpr);
 263         }
 264
 265         // Second, check to see if it's a DSP56001 fixup, and force the FU_56001
 266         // flag into the attributes if so; also save the current org address.
 267         if (attr & FUMASKDSP)
 268         {
 269                 attr |= FU_56001;
 270                 _orgaddr = orgaddr;
 271         }
 272
 273         // Allocate space for the fixup + any expression
 274         FIXUP * fixup = malloc(sizeof(FIXUP) + (sizeof(TOKEN) * exprlen));
 275
 276         // Store the relevant fixup information in the FIXUP
 277         fixup->next = NULL;
 278         fixup->attr = attr;
 279         fixup->loc = loc;
 280         fixup->fileno = cfileno;
 281         fixup->lineno = curlineno;
 282         fixup->expr = NULL;
 283         fixup->symbol = symbol;
 284         fixup->orgaddr = _orgaddr;
 285
 286         // Copy the passed in expression to the FIXUP, if any
 287         if (exprlen > 0)
 288         {
 289                 fixup->expr = (TOKEN *)((uint8_t *)fixup + sizeof(FIXUP));
 290                 memcpy(fixup->expr, fexpr, sizeof(TOKEN) * exprlen);
 291         }
 292
 293         // Finally, put the FIXUP in the current section's linked list
 294         if (sect[cursect].sffix == NULL)
 295         {
 296                 sect[cursect].sffix = fixup;
 297                 sect[cursect].sfix = fixup;
 298         }
 299         else
 300         {
 301                 sect[cursect].sfix->next = fixup;
 302                 sect[cursect].sfix = fixup;
 303         }
 304
 305         DEBUG { printf("AddFixup: sno=%u, l#=%u, attr=$%X, loc=$%X, expr=%p, sym=%p, org=$%X\n", cursect, fixup->lineno, fixup->attr, fixup->loc, (void *)fixup->expr, (void *)fixup->symbol, fixup->orgaddr);
 306                 if (symbol != NULL)
 307                         printf("          name: %s, value: $%lX\n", symbol->sname, symbol->svalue);
 308         }
 309
 310         return 0;
 311 }
 312
 313
 314 //
 315 // Resolve fixups in the passed in section
 316 //
 317 int ResolveFixups(int sno)
 318 {
 319         SECT * sc = &sect[sno];
 320
 321         // "Cache" first chunk
 322         CHUNK * cch = sc->sfcode;
 323
 324         // Can't fixup a section with nothing in it
 325         if (cch == NULL)
 326                 return 0;
 327
 328         // Wire the 6502 segment's size to its allocated size (64K)
 329         if (sno == M6502)
 330                 cch->ch_size = cch->challoc;
 331
 332         // Get first fixup for the passed in section
 333         FIXUP * fixup = sect[sno].sffix;
 334
 335         while (fixup != NULL)
 336         {
 337                 // We do it this way because we have continues everywhere... :-P
 338                 FIXUP * fup = fixup;
 339                 fixup = fixup->next;
 340
 341                 uint32_t dw = fup->attr;        // Fixup long (type + modes + flags)
 342                 uint32_t loc = fup->loc;        // Location to fixup
 343                 cfileno = fup->fileno;
 344                 curlineno = fup->lineno;
 345                 DEBUG { printf("ResolveFixups: sect#=%u, l#=%u, attr=$%X, loc=$%X, expr=%p, sym=%p, org=$%X\n", sno, fup->lineno, fup->attr, fup->loc, (void *)fup->expr, (void *)fup->symbol, fup->orgaddr); }
 346
 347                 // This is based on global vars cfileno, curfname :-P
 348                 // This approach is kinda meh as well. I think we can do better
 349                 // than this.
 350                 SetFilenameForErrorReporting();
 351
 352                 // Search for chunk containing location to fix up; compute a
 353                 // pointer to the location (in the chunk). Often we will find the
 354                 // Fixup is in the "cached" chunk, so the linear-search is seldom
 355                 // executed.
 356                 if (loc < cch->chloc || loc >= (cch->chloc + cch->ch_size))
 357                 {
 358                         for(cch=sc->sfcode; cch!=NULL; cch=cch->chnext)
 359                         {
 360                                 if (loc >= cch->chloc && loc < (cch->chloc + cch->ch_size))
 361                                         break;
 362                         }
 363
 364                         if (cch == NULL)
 365                         {
 366                                 // Fixup (loc) is out of range--this should never happen!
 367                                 // Once we call this function, it winds down immediately; it
 368                                 // doesn't return.
 369                                 interror(7);
 370                         }
 371                 }
 372
 373                 // Location to fix (in current chunk)
 374                 // We use the address of the chunk that loc is actually in, then
 375                 // subtract the chunk's starting location from loc to get the offset
 376                 // into the current chunk.
 377                 uint8_t * locp = cch->chptr + (loc - cch->chloc);
 378
 379                 uint16_t eattr = 0;                     // Expression attrib
 380                 SYM * esym = NULL;                      // External symbol involved in expr
 381                 uint64_t eval;                          // Expression value
 382                 uint16_t flags;                         // Mark flags
 383
 384                 // Compute expression/symbol value and attributes
 385
 386                 // Complex expression
 387                 if (dw & FU_EXPR)
 388                 {
 389                         if (evexpr(fup->expr, &eval, &eattr, &esym) != OK)
 390                                 continue;
 391                 }
 392                 // Simple symbol
 393                 else
 394                 {
 395                         SYM * sy = fup->symbol;
 396                         eattr = sy->sattr;
 397
 398                         if (eattr & DEFINED)
 399                                 eval = sy->svalue;
 400                         else
 401                                 eval = 0;
 402
 403                         // If the symbol is not defined, but global, set esym to sy
 404                         if ((eattr & (GLOBAL | DEFINED)) == GLOBAL)
 405                                 esym = sy;
 406                 }
 407
 408                 uint16_t tdb = eattr & TDB;
 409
 410                 // If the expression/symbol is undefined and no external symbol is
 411                 // involved, then that's an error.
 412                 if (!(eattr & DEFINED) && (esym == NULL))
 413                 {
 414                         error(undef_error);
 415                         continue;
 416                 }
 417
 418                 // Do the fixup
 419                 //
 420                 // If a PC-relative fixup is undefined, its value is *not* subtracted
 421                 // from the location (that will happen in the linker when the external
 422                 // reference is resolved).
 423                 //
 424                 // MWC expects PC-relative things to have the LOC subtracted from the
 425                 // value, if the value is external (that is, undefined at this point).
 426                 //
 427                 // PC-relative fixups must be DEFINED and either in the same section
 428                 // (whereupon the subtraction takes place) or ABS (with no subtract).
 429                 if (dw & FU_PCREL)
 430                 {
 431                         if (eattr & DEFINED)
 432                         {
 433                                 if (tdb == sno)
 434                                         eval -= loc;
 435                                 else if (tdb)
 436                                 {
 437                                         // Allow cross-section PCREL fixups in Alcyon mode
 438                                         if (prg_flag)
 439                                         {
 440                                                 switch (tdb)
 441                                                 {
 442                                                 case TEXT:
 443 // Shouldn't there be a break here, since otherwise, it will point to the DATA section?
 444 //                                                      break;
 445                                                 case DATA:
 446                                                         eval += sect[TEXT].sloc;
 447                                                         break;
 448                                                 case BSS:
 449                                                         eval += sect[TEXT].sloc + sect[DATA].sloc;
 450                                                         break;
 451                                                 default:
 452                                                         error("invalid section");
 453                                                 break;
 454                                                 }
 455
 456                                                 eval -= loc;
 457                                         }
 458                                         else
 459                                         {
 460                                                 error("PC-relative expr across sections");
 461                                                 continue;
 462                                         }
 463                                 }
 464
 465                                 if (sbra_flag && (dw & FU_LBRA) && (eval + 0x80 < 0x100))
 466                                         warn("unoptimized short branch");
 467                         }
 468                         else if (obj_format == MWC)
 469                                 eval -= loc;
 470
 471                         tdb = 0;
 472                         eattr &= ~TDB;
 473                 }
 474
 475                 // Handle fixup classes
 476                 switch (dw & FUMASK)
 477                 {
 478                 // FU_BBRA fixes up a one-byte branch offset.
 479                 case FU_BBRA:
 480                         if (!(eattr & DEFINED))
 481                         {
 482                                 error("external short branch");
 483                                 continue;
 484                         }
 485
 486                         eval -= 2;
 487
 488                         if (eval + 0x80 >= 0x100)
 489                                 goto rangeErr;
 490
 491                         if (eval == 0)
 492                         {
 493                                 if (CHECK_OPTS(OPT_NULL_BRA))
 494                                 {
 495                                         // Just output a NOP
 496                                         *locp++ = 0x4E;
 497                                         *locp = 0x71;
 498                                         continue;
 499                                 }
 500                                 else
 501                                 {
 502                                         error("illegal bra.s with zero offset");
 503                                         continue;
 504                                 }
 505                         }
 506
 507                         *++locp = (uint8_t)eval;
 508                         break;
 509
 510                 // Fixup one-byte value at locp + 1.
 511                 case FU_WBYTE:
 512                         locp++;
 513                         // FALLTHROUGH
 514
 515                 // Fixup one-byte forward references
 516                 case FU_BYTE:
 517                         if (!(eattr & DEFINED))
 518                         {
 519                                 error("external byte reference");
 520                                 continue;
 521                         }
 522
 523                         if (tdb)
 524                         {
 525                                 error("non-absolute byte reference");
 526                                 continue;
 527                         }
 528
 529                         if ((dw & FU_PCREL) && ((eval + 0x80) >= 0x100))
 530                                 goto rangeErr;
 531
 532                         if (dw & FU_SEXT)
 533                         {
 534                                 if ((eval + 0x100) >= 0x200)
 535                                         goto rangeErr;
 536                         }
 537                         else if (eval >= 0x100)
 538                                 goto rangeErr;
 539
 540                         *locp = (uint8_t)eval;
 541                         break;
 542
 543                 // Fixup high/low byte off word for 6502
 544                 case FU_BYTEH:
 545                         if (!(eattr & DEFINED))
 546                         {
 547                                 error("external byte reference");
 548                                 continue;
 549                         }
 550
 551                         *locp = (uint8_t)(eval >> 8);
 552                         break;
 553
 554                 case FU_BYTEL:
 555                         if (!(eattr & DEFINED))
 556                         {
 557                                 error("external byte reference");
 558                                 continue;
 559                         }
 560
 561                         *locp = (uint8_t)eval;
 562                         break;
 563
 564                 // Fixup WORD forward references; the word could be unaligned in the
 565                 // section buffer, so we have to be careful. (? careful about what?)
 566                 case FU_WORD:
 567                         if ((dw & FUMASKRISC) == FU_JR)
 568                         {
 569 #if 0
 570                                 int reg;
 571
 572                                 if (fup->orgaddr)
 573                                         reg = (signed)((eval - (fup->orgaddr + 2)) / 2);
 574                                 else
 575                                         reg = (signed)((eval - (loc + 2)) / 2);
 576 #else
 577                                 int reg = (signed)((eval - ((fup->orgaddr ? fup->orgaddr : loc) + 2)) / 2);
 578 #endif
 579
 580                                 if ((reg < -16) || (reg > 15))
 581                                 {
 582                                         error("relative jump out of range");
 583                                         break;
 584                                 }
 585
 586                                 *locp |= ((uint8_t)reg >> 3) & 0x03;
 587                                 locp++;
 588                                 *locp |= ((uint8_t)reg & 0x07) << 5;
 589                                 break;
 590                         }
 591                         else if ((dw & FUMASKRISC) == FU_NUM15)
 592                         {
 593                                 if (((int)eval < -16) || ((int)eval > 15))
 594                                 {
 595                                         error("constant out of range (-16 - +15)");
 596                                         break;
 597                                 }
 598
 599                                 *locp |= ((uint8_t)eval >> 3) & 0x03;
 600                                 locp++;
 601                                 *locp |= ((uint8_t)eval & 0x07) << 5;
 602                                 break;
 603                         }
 604                         else if ((dw & FUMASKRISC) == FU_NUM31)
 605                         {
 606                                 if (eval > 31)
 607                                 {
 608                                         error("constant out of range (0-31)");
 609                                         break;
 610                                 }
 611
 612                                 *locp |= ((uint8_t)eval >> 3) & 0x03;
 613                                 locp++;
 614                                 *locp |= ((uint8_t)eval & 0x07) << 5;
 615                                 break;
 616                         }
 617                         else if ((dw & FUMASKRISC) == FU_NUM32)
 618                         {
 619                                 if ((eval < 1) || (eval > 32))
 620                                 {
 621                                         error("constant out of range (1-32)");
 622                                         break;
 623                                 }
 624
 625                                 if (dw & FU_SUB32)
 626                                         eval = (32 - eval);
 627
 628                                 eval = (eval == 32) ? 0 : eval;
 629                                 *locp |= ((uint8_t)eval >> 3) & 0x03;
 630                                 locp++;
 631                                 *locp |= ((uint8_t)eval & 0x07) << 5;
 632                                 break;
 633                         }
 634                         else if ((dw & FUMASKRISC) == FU_REGONE)
 635                         {
 636                                 if (eval > 31)
 637                                 {
 638                                         error("register one value out of range");
 639                                         break;
 640                                 }
 641
 642                                 *locp |= ((uint8_t)eval >> 3) & 0x03;
 643                                 locp++;
 644                                 *locp |= ((uint8_t)eval & 0x07) << 5;
 645                                 break;
 646                         }
 647                         else if ((dw & FUMASKRISC) == FU_REGTWO)
 648                         {
 649                                 if (eval > 31)
 650                                 {
 651                                         error("register two value out of range");
 652                                         break;
 653                                 }
 654
 655                                 locp++;
 656                                 *locp |= (uint8_t)eval & 0x1F;
 657                                 break;
 658                         }
 659
 660                         if (!(eattr & DEFINED))
 661                         {
 662                                 flags = MWORD;
 663
 664                                 if (dw & FU_PCREL)
 665                                         flags |= MPCREL;
 666
 667                                 MarkRelocatable(sno, loc, 0, flags, esym);
 668                         }
 669                         else
 670                         {
 671                                 if (tdb)
 672                                         MarkRelocatable(sno, loc, tdb, MWORD, NULL);
 673
 674                                 if (dw & FU_SEXT)
 675                                 {
 676                                         if (eval + 0x10000 >= 0x20000)
 677                                                 goto rangeErr;
 678                                 }
 679                                 else
 680                                 {
 681                                         // Range-check BRA and DBRA
 682                                         if (dw & FU_ISBRA)
 683                                         {
 684                                                 if (eval + 0x8000 >= 0x10000)
 685                                                         goto rangeErr;
 686                                         }
 687                                         else if (eval >= 0x10000)
 688                                                 goto rangeErr;
 689                                 }
 690                         }
 691
 692                         // 6502 words are little endian, so handle that here
 693                         if (sno == M6502)
 694                                 SETLE16(locp, 0, eval)
 695                         else
 696                                 SETBE16(locp, 0, eval)
 697
 698                         break;
 699
 700                 // Fixup LONG forward references; the long could be unaligned in the
 701                 // section buffer, so be careful (again).
 702                 case FU_LONG:
 703                         flags = MLONG;
 704
 705                         if ((dw & FUMASKRISC) == FU_MOVEI)
 706                         {
 707                                 // Long constant in MOVEI # is word-swapped, so fix it here
 708                                 eval = WORDSWAP32(eval);
 709                                 flags |= MMOVEI;
 710                         }
 711
 712                         // If the symbol is undefined, make sure to pass the symbol in
 713                         // to the MarkRelocatable() function.
 714                         if (!(eattr & DEFINED))
 715                                 MarkRelocatable(sno, loc, 0, flags, esym);
 716                         else if (tdb)
 717                                 MarkRelocatable(sno, loc, tdb, flags, NULL);
 718
 719                         SETBE32(locp, 0, eval);
 720                         break;
 721
 722                 // Fixup QUAD forward references (mainly used by the OP assembler)
 723                 case FU_QUAD:
 724                         if (dw & FU_OBJLINK)
 725                         {
 726                                 uint64_t quad = GETBE64(locp, 0);
 727                                 uint64_t addr = eval;
 728
 729 //Hmm, not sure how this can be set, since it's only set if it's a DSP56001 fixup or a FU_JR...  :-/
 730                                 if (fup->orgaddr)
 731                                         addr = fup->orgaddr;
 732
 733                                 eval = (quad & 0xFFFFFC0000FFFFFFLL) | ((addr & 0x3FFFF8) << 21);
 734                         }
 735                         else if (dw & FU_OBJDATA)
 736                         {
 737                                 // If it's in a TEXT or DATA section, be sure to mark for a
 738                                 // fixup later
 739                                 if (tdb)
 740                                         MarkRelocatable(sno, loc, tdb, MQUAD, NULL);
 741
 742                                 uint64_t quad = GETBE64(locp, 0);
 743                                 uint64_t addr = eval;
 744
 745 //Hmm, not sure how this can be set, since it's only set if it's a DSP56001 fixup or a FU_JR...  :-/
 746                                 if (fup->orgaddr)
 747                                         addr = fup->orgaddr;
 748
 749                                 eval = (quad & 0x000007FFFFFFFFFFLL) | ((addr & 0xFFFFF8) << 40);
 750                         }
 751
 752                         SETBE64(locp, 0, eval);
 753                         break;
 754
 755                 // Fixup a 3-bit "QUICK" reference in bits 9..1
 756                 // (range of 1..8) in a word. [Really bits 1..3 in a byte.]
 757                 case FU_QUICK:
 758                         if (!(eattr & DEFINED))
 759                         {
 760                                 error("External quick reference");
 761                                 continue;
 762                         }
 763
 764                         if ((eval < 1) || (eval > 8))
 765                                 goto rangeErr;
 766
 767                         *locp |= (eval & 7) << 1;
 768                         break;
 769
 770                 // Fix up 6502 funny branch
 771                 case FU_6BRA:
 772                         eval -= (loc + 1);
 773
 774                         if (eval + 0x80 >= 0x100)
 775                                 goto rangeErr;
 776
 777                         *locp = (uint8_t)eval;
 778                         break;
 779
 780                 // Fixup DSP56001 addresses
 781                 case FU_56001:
 782                         switch (dw & FUMASKDSP)
 783                         {
 784                         // DSPIMM5 actually is clamped from 0 to 23 for our purposes
 785                         // and does not use the full 5 bit range.
 786                         case FU_DSPIMM5:
 787                                 if (eval > 23)
 788                                 {
 789                                         error("immediate value must be between 0 and 23");
 790                                         break;
 791                                 }
 792
 793                                 locp[2] |= eval;
 794                                 break;
 795
 796                         // This is a 12-bit address encoded into the lower 12
 797                         // bits of a DSP word
 798                         case FU_DSPADR12:
 799                                 if (eval >= 0x1000)
 800                                 {
 801                                         error("address out of range ($000-$FFF)");
 802                                         break;
 803                                 }
 804
 805                                 locp[1] |= eval >> 8;
 806                                 locp[2] = eval & 0xFF;
 807                                 break;
 808
 809                         // This is a full DSP word containing Effective Address Extension
 810                         case FU_DSPADR24:
 811                         case FU_DSPIMM24:
 812                                 if (eval >= 0x100000)
 813                                 {
 814                                         error("value out of range ($000-$FFFFFF)");
 815                                         break;
 816                                 }
 817
 818                                 *locp++ = (uint32_t)eval >> 16;
 819                                 *locp++ = ((uint32_t)eval >> 8) & 0xFF;
 820                                 *locp++ = (uint32_t)eval & 0xFF;
 821                                 break;
 822
 823                         // This is a 16bit absolute address into a 24bit field
 824                         case FU_DSPADR16:
 825                                 if (eval >= 0x10000)
 826                                 {
 827                                         error("address out of range ($0000-$FFFF)");
 828                                         break;
 829                                 }
 830
 831                                 locp[1] = (uint8_t)(eval >> 8);
 832                                 locp[2] = (uint8_t)eval;
 833                                 break;
 834
 835                         // This is 12-bit immediate short data
 836                         // The upper nibble goes into the last byte's low nibble
 837                         // while the remainder 8 bits go into the 2nd byte.
 838                         case FU_DSPIMM12:
 839                                 if (eval >= 0x1000)
 840                                 {
 841                                         error("immediate out of range ($000-$FFF)");
 842                                         break;
 843                                 }
 844
 845                                 locp[1] = (uint8_t)eval;
 846                                 locp[2] |= (uint8_t)(eval >> 8);
 847                                 break;
 848
 849                         // This is 8-bit immediate short data
 850                         // which goes into the middle byte of a DSP word.
 851                         case FU_DSPIMM8:
 852                                 if (eval >= 0x100)
 853                                 {
 854                                         error("immediate out of range ($00-$FF)");
 855                                         break;
 856                                 }
 857
 858                                 locp[1] = (uint8_t)eval;
 859                                 break;
 860
 861                         // This is a 6 bit absoulte short address. It occupies
 862                         // the low 6 bits of the middle byte of a DSP word.
 863                         case FU_DSPADR06:
 864                                 if (eval > 63)
 865                                 {
 866                                         error("address must be between 0 and 63");
 867                                         break;
 868                                 }
 869
 870                                 locp[1] |= eval;
 871                                 break;
 872
 873                         // This is a 6 bit absoulte short address. It occupies
 874                         // the low 6 bits of the middle byte of a DSP word.
 875                         case FU_DSPPP06:
 876                                 if (eval < 0xFFFFFFC0)
 877                                 {
 878                                         error("address must be between $FFC0 and $FFFF");
 879                                         break;
 880                                 }
 881
 882                                 locp[1] |= eval & 0x3F;
 883                                 break;
 884
 885                         // Shamus: I'm pretty sure these don't make any sense...
 886                         case FU_DSPIMMFL8:
 887                                 warn("FU_DSPIMMFL8 missing implementation\n%s", "And you may ask yourself, \"Self, how did I get here?\"");
 888                                 break;
 889
 890                         case FU_DSPIMMFL16:
 891                                 warn("FU_DSPIMMFL16 missing implementation\n%s", "And you may ask yourself, \"Self, how did I get here?\"");
 892                                 break;
 893
 894                         case FU_DSPIMMFL24:
 895                                 warn("FU_DSPIMMFL24 missing implementation\n%s", "And you may ask yourself, \"Self, how did I get here?\"");
 896                                 break;
 897
 898                         // Bad fixup type--this should *never* happen!
 899                         default:
 900                                 interror(4);
 901                                 // NOTREACHED
 902                         }
 903                         break;
 904
 905                 // Fixup a 4-byte float
 906                 case FU_FLOATSING:
 907                         warn("FU_FLOATSING missing implementation\n%s", "And you may ask yourself, \"Self, how did I get here?\"");
 908                         break;
 909
 910                 // Fixup a 8-byte float
 911                 case FU_FLOATDOUB:
 912                         warn("FU_FLOATDOUB missing implementation\n%s", "And you may ask yourself, \"Self, how did I get here?\"");
 913                         break;
 914
 915                 // Fixup a 12-byte float
 916                 case FU_FLOATEXT:
 917                         warn("FU_FLOATEXT missing implementation\n%s", "And you may ask yourself, \"Self, how did I get here?\"");
 918                         break;
 919
 920                 default:
 921                         // Bad fixup type--this should *never* happen!
 922                         // Once we call this function, it winds down immediately; it
 923                         // doesn't return.
 924                         interror(4);
 925                 }
 926
 927                 continue;
 928 rangeErr:
 929                 error("expression out of range");
 930         }
 931
 932         return 0;
 933 }
 934
 935
 936 //
 937 // Resolve all fixups
 938 //
 939 int ResolveAllFixups(void)
 940 {
 941         // Make undefined symbols GLOBL
 942         if (glob_flag)
 943                 ForceUndefinedSymbolsGlobal();
 944
 945         DEBUG printf("Resolving TEXT sections...\n");
 946         ResolveFixups(TEXT);
 947         DEBUG printf("Resolving DATA sections...\n");
 948         ResolveFixups(DATA);
 949         DEBUG printf("Resolving 6502 sections...\n");
 950         ResolveFixups(M6502);           // Fixup 6502 section (if any)
 951
 952         return 0;
 953 }
 954