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

   1 ////////////////////////////////////////////////////////////////////////////////////////////////////
   2 // RMAC - Reboot's Macro Assembler for the Atari Jaguar Console System
   3 // SECT.C - Code Generation, Fixups and Section Management
   4 // Copyright (C) 199x Landon Dyer, 2011 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 #include "sect.h"
   9 #include "error.h"
  10 #include "mach.h"
  11 #include "token.h"
  12 #include "mark.h"
  13 #include "expr.h"
  14 #include "symbol.h"
  15 #include "risca.h"
  16 #include "listing.h"
  17
  18 // Section descriptors
  19 SECT sect[NSECTS];                                          // All sections...
  20 int cursect;                                                // Current section number
  21
  22 // These are copied from the section descriptor, the current code chunk descriptor and the current
  23 // fixup chunk descriptor when a switch is made into a section.  They are copied back to the
  24 // descriptors when the section is left.
  25 WORD scattr;                                                // Section attributes
  26 LONG sloc;                                                  // Current loc in section
  27
  28 CHUNK *scode;                                               // Current (last) code chunk
  29 LONG challoc;                                               // #bytes alloc'd to code chunk
  30 LONG ch_size;                                               // #bytes used in code chunk
  31 char *chptr;                                                // Deposit point in code chunk buffer
  32
  33 CHUNK *sfix;                                                // Current (last) fixup chunk
  34 LONG fchalloc;                                              // #bytes alloc'd to fixup chunk
  35 LONG fchsize;                                               // #bytes used in fixup chunk
  36 PTR fchptr;                                                 // Deposit point in fixup chunk buffer
  37
  38 unsigned fwdjump[MAXFWDJUMPS];                              // forward jump check table
  39 unsigned fwindex = 0;                                       // forward jump index
  40
  41 // Return a size (SIZB, SIZW, SIZL) or 0, depending on what kind of fixup is associated
  42 // with a location.
  43 static char fusiztab[] = {
  44    0,                                                       // FU_QUICK
  45    1,                                                       // FU_BYTE
  46    2,                                                       // FU_WORD
  47    2,                                                       // FU_WBYTE
  48    4,                                                       // FU_LONG
  49    1,                                                       // FU_BBRA
  50    0,                                                       // (unused)
  51    1,                                                       // FU_6BRA
  52 };
  53
  54 // Offset to REAL fixup location
  55 static char fusizoffs[] = {
  56    0,                                                       // FU_QUICK
  57    0,                                                       // FU_BYTE
  58    0,                                                       // FU_WORD
  59    1,                                                       // FU_WBYTE
  60    0,                                                       // FU_LONG
  61    1,                                                       // FU_BBRA
  62    0,                                                       // (unused)
  63    0,                                                       // FU_6BRA
  64 };
  65
  66 //
  67 // --- Make a New (Clean) Section ------------------------------------------------------------------
  68 //
  69
  70 void mksect(int sno, WORD attr) {
  71    SECT *p;                                                 // Section pointer
  72
  73    p = &sect[sno];
  74    p->scattr = attr;
  75    p->sloc = 0;
  76    p->scode = p->sfcode = NULL;
  77    p->sfix = p->sffix = NULL;
  78 }
  79
  80 //
  81 // --- Switch to Another Section (Copy Section & Chunk Descriptors to Global Vars for Fast Access) -
  82 //
  83
  84 void switchsect(int sno) {
  85    SECT *p;                                                 // Section pointer
  86    CHUNK *cp;                                               // Chunk pointer
  87
  88    cursect = sno;
  89    p = &sect[sno];
  90
  91    scattr = p->scattr;                                      // Copy section vars
  92    sloc = p->sloc;
  93    scode = p->scode;
  94    sfix = p->sfix;
  95
  96    if((cp = scode) != NULL) {                               // Copy code chunk vars
  97       challoc = cp->challoc;
  98       ch_size = cp->ch_size;
  99       chptr = cp->chptr + ch_size;
 100    } else challoc = ch_size = 0;
 101
 102    if((cp = sfix) != NULL) {                                // Copy fixup chunk vars
 103       fchalloc = cp->challoc;
 104       fchsize = cp->ch_size;
 105       fchptr.cp = cp->chptr + fchsize;
 106    } else fchalloc = fchsize = 0;
 107 }
 108
 109 //
 110 // --- Save Current Section ------------------------------------------------------------------------
 111 //
 112
 113 void savsect(void) {
 114    SECT *p;
 115
 116    p = &sect[cursect];
 117
 118    p->scattr = scattr;                                      // Bailout section vars
 119    p->sloc = sloc;
 120
 121    if(scode != NULL)                                        // Bailout code chunk
 122       scode->ch_size = ch_size;
 123
 124    if(sfix != NULL)                                         // Bailout fixup chunk
 125       sfix->ch_size = fchsize;
 126 }
 127
 128 //
 129 // --- Initialize Sections; Setup initial ABS, TEXT, DATA and BSS sections -------------------------
 130 //
 131
 132 void init_sect(void) {
 133    int i;                                                   // Iterator
 134
 135    // Cleanup all sections
 136    for(i = 0; i < NSECTS; ++i)
 137       mksect(i, 0);
 138
 139    // Construct default sections, make TEXT the current section
 140    mksect(ABS,   SUSED|SABS|SBSS);                          // ABS
 141    mksect(TEXT,  SUSED|TEXT     );                          // TEXT
 142    mksect(DATA,  SUSED|DATA     );                          // DATA
 143    mksect(BSS,   SUSED|BSS |SBSS);                          // BSS
 144 //   mksect(M6502, SUSED|TEXT     );                          // 6502 code section
 145
 146    switchsect(TEXT);                                        // Switch to TEXT for starters
 147 }
 148
 149 //
 150 // -------------------------------------------------------------------------------------------------
 151 // Test to see if a location has a fixup sic'd on it.  This is used by the listing
 152 // generator to print 'xx's instead of '00's for forward references
 153 // -------------------------------------------------------------------------------------------------
 154 //
 155
 156 int fixtest(int sno, LONG loc) {
 157    CHUNK *ch;
 158    PTR fup;
 159    char *fuend;
 160    WORD w;
 161    LONG xloc;
 162
 163    stopmark();                                              // Force update to sect[] variables
 164
 165    // Hairy, ugly linear search for a mark on our location;
 166    // the speed doesn't matter, since this is only done when generating a listing, which is SLOW.
 167    for(ch = sect[sno].sffix; ch != NULL; ch = ch->chnext) {
 168       fup.cp = (char *)ch->chptr;
 169       fuend = fup.cp + ch->ch_size;
 170
 171       while(fup.cp < fuend) {
 172          w = *fup.wp++;
 173          xloc = *fup.lp++ + (int)fusizoffs[w & FUMASK];
 174          fup.wp += 2;
 175
 176          if(xloc == loc)
 177             return((int)fusiztab[w & FUMASK]);
 178
 179          if(w & FU_EXPR) {
 180             w = *fup.wp++;
 181             fup.lp += w;
 182          } else ++fup.lp;
 183       }
 184    }
 185
 186    return(0);
 187 }
 188
 189 //
 190 // -------------------------------------------------------------------------------------------------
 191 // Check that there are at least `amt' bytes left in the current chunk.  If there are not,
 192 // allocate another chunk of at least `amt' bytes (and probably more).
 193 //
 194 // If `amt' is zero, ensure there are at least CH_THRESHOLD bytes, likewise.
 195 // -------------------------------------------------------------------------------------------------
 196 //
 197
 198 int chcheck(LONG amt) {
 199    CHUNK *cp;
 200    SECT *p;
 201
 202    if(scattr & SBSS) return(0);                             // If in BSS section, forget it
 203
 204    if(!amt) amt = CH_THRESHOLD;
 205
 206    if((int)(challoc - ch_size) >= (int)amt)
 207       return(0);
 208
 209    if(amt < CH_CODE_SIZE) amt = CH_CODE_SIZE;
 210    p = &sect[cursect];
 211    cp = (CHUNK *)amem((long)(sizeof(CHUNK) + amt));
 212    if(scode == NULL) {                                      // First chunk in section
 213       cp->chprev = NULL;
 214       p->sfcode = cp;
 215    } else {                                                 // Add chunk to other chunks
 216       cp->chprev = scode;
 217       scode->chnext = cp;
 218       scode->ch_size = ch_size;                             // Save old chunk's globals
 219    }
 220
 221    // Setup chunk and global vars
 222    cp->chloc = sloc;
 223    cp->chnext = NULL;
 224    challoc = cp->challoc = amt;
 225    ch_size = cp->ch_size = 0;
 226    chptr = cp->chptr = ((char *)cp) + sizeof(CHUNK);
 227    scode = p->scode = cp;
 228
 229    return(0);
 230 }
 231
 232 //
 233 // --- Arrange for a fixup on a location -----------------------------------------------------------
 234 //
 235
 236 int fixup(WORD attr, LONG loc, TOKEN *fexpr) {
 237    LONG i;
 238    LONG len = 0;
 239    CHUNK *cp;
 240    SECT *p;
 241
 242    // Compute length of expression (could be faster); determine if it's the single-symbol case;
 243    // no expression if it's just a mark. This code assumes 16 bit WORDs and 32 bit LONGs
 244    if(*fexpr == SYMBOL && fexpr[2] == ENDEXPR)
 245       //if((attr & 0x0F00) == FU_JR) {
 246       if((attr & 0x0200) == FU_JR) {
 247          i = 18;                  // Just a single symbol
 248       } else {
 249          i = 14;
 250       }
 251    else {
 252       attr |= FU_EXPR;
 253       for(len = 0; fexpr[len] != ENDEXPR; ++len)
 254          if(fexpr[len] == CONST || fexpr[len] == SYMBOL)
 255             ++len;
 256       ++len;                                                // Add 1 for ENDEXPR
 257       i = (len << 2) + 12;
 258    }
 259
 260    // Maybe alloc another fixup chunk for this one to fit in
 261    if((fchalloc - fchsize) < i) {
 262       p = &sect[cursect];
 263           cp = (CHUNK *)amem((long)(sizeof(CHUNK) + CH_FIXUP_SIZE));
 264       if(sfix == NULL) {                                 // First fixup chunk in section
 265          cp->chprev = NULL;
 266          p->sffix = cp;
 267       } else {                                           // Add to other chunks
 268          cp->chprev = sfix;
 269          sfix->chnext = cp;
 270          sfix->ch_size = fchsize;
 271       }
 272
 273       // Setup fixup chunk and its global vars
 274       cp->chnext = NULL;
 275       fchalloc = cp->challoc = CH_FIXUP_SIZE;
 276       fchsize = cp->ch_size = 0;
 277       fchptr.cp = cp->chptr = ((char *)cp) + sizeof(CHUNK);
 278       sfix = p->sfix = cp;
 279    }
 280
 281    // Record fixup type, fixup location, and the file number and line number the fixup is
 282    // located at.
 283    *fchptr.wp++ = attr;
 284    *fchptr.lp++ = loc;
 285    *fchptr.wp++ = cfileno;
 286    *fchptr.wp++ = (WORD)curlineno;
 287    // Store postfix expression or pointer to a single symbol, or nothing for a mark.
 288    if(attr & FU_EXPR) {
 289       *fchptr.wp++ = (WORD)len;
 290       while(len--)
 291          *fchptr.lp++ = (LONG)*fexpr++;
 292    } else  {
 293       *fchptr.lp++ = (LONG)fexpr[1];
 294    }
 295
 296    //if((attr & 0x0F00) == FU_JR) {
 297    if((attr & 0x0200) == FU_JR) {
 298       if(orgactive) *fchptr.lp++ = orgaddr;
 299       else *fchptr.lp++ = 0x00000000;
 300    }
 301
 302    fchsize += i;
 303
 304    return(0);
 305 }
 306
 307 //
 308 // --- Resolve all Fixups --------------------------------------------------------------------------
 309 //
 310
 311 int fixups(void) {
 312    unsigned i;                                              // Iterator
 313    char buf[EBUFSIZ];
 314
 315    if(glob_flag)                                            // Make undefined symbols GLOBL
 316       syg_fix();
 317    resfix(TEXT);
 318    resfix(DATA);
 319
 320    // We need to do a final check of forward 'jump' destination addresses that are external
 321    for(i = 0; i < MAXFWDJUMPS; i++) {
 322       if(fwdjump[i]) {
 323          err_setup();
 324          sprintf(buf, "* \'jump\' at $%08X - destination address is external to this source file and "
 325                  "cannot have its aligment validated", fwdjump[i]);
 326          if(listing > 0) ship_ln(buf);
 327          if(err_flag) write(err_fd, buf, (LONG)strlen(buf));
 328          else printf("%s\n", buf);
 329       }
 330    }
 331
 332    return(0);
 333 }
 334
 335 //
 336 // --- Resolve Fixups in a Section -----------------------------------------------------------------
 337 //
 338
 339 int resfix(int sno) {
 340    SECT *sc;                                                // Section
 341    CHUNK *ch;
 342    PTR fup;                                                 // Current fixup
 343    WORD *fuend;                                             // End of last fixup (in this chunk)
 344    CHUNK *cch;                                              // Cached chunk for target
 345    WORD w;                                                  // Fixup word (type+modes+flags)
 346    char *locp;                                              // Location to fix (in cached chunk)
 347    LONG loc;                                                // Location to fixup
 348    VALUE eval;                                              // Expression value
 349    WORD eattr;                                              // Expression attrib
 350    SYM *esym;                                               // External symbol involved in expr
 351    SYM *sy;                                                 // (Temp) pointer to a symbol
 352    WORD i;                                                  // (Temp) word
 353    WORD tdb;                                                // eattr & TDB
 354    LONG oaddr;
 355    int reg2;
 356    WORD flags;
 357    unsigned page_jump = 0;
 358    unsigned address = 0;
 359    unsigned j;                                              // iterator
 360    char buf[EBUFSIZ];
 361
 362    sc = &sect[sno];
 363    ch = sc->sffix;
 364
 365    if(ch == NULL)
 366       return(0);
 367
 368    cch = sc->sfcode;                                        // "cache" first chunk
 369    if(cch == NULL)                                          // Can't fixup a sect with nothing in it
 370       return(0);
 371
 372    do {
 373       fup.cp = ch->chptr;                                   // fup -> start of chunk
 374       fuend = (WORD *)(fup.cp + ch->ch_size);               // fuend -> end of chunk
 375       while(fup.wp < fuend) {
 376          w = *fup.wp++;
 377          loc = *fup.lp++;
 378          cfileno = *fup.wp++;
 379          curlineno = (int)*fup.wp++;
 380
 381          esym = NULL;
 382          // Search for chunk containing location to fix up; compute a pointer to the location
 383          // (in the chunk). Often we will find the fixup is in the "cached" chunk, so the
 384          // linear-search is seldom executed.
 385          if(loc < cch->chloc || loc >= (cch->chloc + cch->ch_size)) {
 386             for(cch = sc->sfcode; cch != NULL; cch = cch->chnext)
 387                if(loc >= cch->chloc && loc < (cch->chloc + cch->ch_size))
 388                   break;
 389             if(cch == NULL) {
 390                interror(7);                                 // Fixup (loc) out of range
 391                                         // NOTREACHED
 392             }
 393          }
 394          locp = cch->chptr + (loc - cch->chloc);
 395
 396          eattr = 0;
 397
 398          // Compute expression/symbol value and attribs
 399          if(w & FU_EXPR) {                                  // Complex expression
 400             i = *fup.wp++;
 401             if(evexpr(fup.tk, &eval, &eattr, &esym) != OK) {
 402                fup.lp += i;
 403                continue;
 404             }
 405             fup.lp += i;
 406          } else {                                           // Simple symbol
 407             sy = *fup.sy++;
 408             eattr = sy->sattr;
 409             if(eattr & DEFINED)
 410                eval = sy->svalue;
 411             else eval = 0;
 412
 413             if((eattr & (GLOBAL|DEFINED)) == GLOBAL)
 414                esym = sy;
 415          }
 416          tdb = (WORD)(eattr & TDB);
 417          // If the expression is undefined and no external symbol is involved, then it's an error.
 418          if(!(eattr & DEFINED) && esym == NULL) {
 419             error(undef_error);
 420             continue;
 421          }
 422
 423
 424          if(((w & 0x0F00) == FU_MOVEI) && esym)
 425             esym->sattre |= RISCSYM;
 426
 427          // Do the fixup
 428          //
 429          // If a PC-relative fixup is undefined, its value is *not* subtracted from the location
 430          // (that will happen in the linker when the external reference is resolved).
 431          //
 432          // MWC expects PC-relative things to have the LOC subtracted from the value, if the
 433          // value is external (that is, undefined at this point).
 434          //
 435          // PC-relative fixups must be DEFINED and either in the same section (whereupon the
 436          // subtraction takes place) or ABS (with no subtract).
 437          if(w & FU_PCREL) {
 438             if(eattr & DEFINED) {
 439                if(tdb == sno) eval -= (VALUE)loc;
 440                else if(tdb) {
 441                   error("PC-relative expr across sections");
 442                   continue;
 443                }
 444
 445                if(sbra_flag && (w & FU_LBRA) && (eval + 0x80 < 0x100))
 446                   warn("unoptimized short branch");
 447             } else
 448                if(obj_format == MWC) eval -= (VALUE)loc;
 449
 450             tdb = 0;
 451             eattr &= ~TDB;
 452          }
 453
 454          // Do fixup classes
 455          switch((int)(w & FUMASK)) {
 456             // FU_BBRA fixes up a one-byte branch offset.
 457             case FU_BBRA:
 458                if(!(eattr & DEFINED)) {
 459                   error("external short branch");
 460                   continue;
 461                }
 462                eval -= 2;
 463                if(eval + 0x80 >= 0x100)
 464                   goto range;
 465                if(eval == 0) {
 466                   error("illegal bra.s with zero offset");
 467                   continue;
 468                }
 469                *++locp = (char)eval;
 470                break;
 471             // Fixup one-byte value at locp + 1.
 472             case FU_WBYTE:
 473                ++locp;
 474                // FALLTHROUGH
 475                // Fixup one-byte forward references
 476             case FU_BYTE:
 477                if(!(eattr & DEFINED)) {
 478                   error("external byte reference");
 479                   continue;
 480                }
 481                if(tdb) {
 482                   error("non-absolute byte reference");
 483                   continue;
 484                }
 485                if((w & FU_PCREL) && eval + 0x80 >= 0x100) goto range;
 486                if(w & FU_SEXT) {
 487                   if(eval + 0x100 >= 0x200) goto range;
 488                } else
 489                   if(eval >= 0x100) goto range;
 490
 491                *locp = (char)eval;
 492                break;
 493             // Fixup WORD forward references;
 494             // the word could be unaligned in the section buffer, so we have to be careful.
 495             case FU_WORD:
 496                if(((w & 0x0F00) == FU_JR) || ((w & 0x0F00) == FU_MJR)) {
 497                   oaddr = *fup.lp++;
 498                   if(oaddr) {
 499                      reg2 = (signed)((eval - (oaddr + 2)) / 2);// & 0x1F;
 500                   } else {
 501                      reg2 = (signed)((eval - (loc + 2)) / 2);// & 0x1F;
 502                   }
 503                   if((w & 0x0F00) == FU_MJR) {
 504                      // Main code destination alignment checking here for forward declared labels
 505                      address = (oaddr) ? oaddr : loc;
 506                      if(((address >= 0xF03000) && (address < 0xF04000) && (eval    < 0xF03000)) ||
 507                         ((eval    >= 0xF03000) && (eval    < 0xF04000) && (address < 0xF03000)) ) {
 508                         warni("* \'jr\' at $%08X - cannot jump relative between "
 509                               "main memory and local gpu ram", address);
 510                      } else {
 511                         page_jump = (address & 0xFFFFFF00) - (eval & 0xFFFFFF00);
 512                         if(page_jump) {
 513                            // This jump is to a page outside of the current 256 byte page
 514                            if(eval % 4) {
 515                               warni("* \'jr\' at $%08X - destination address not aligned for long page jump, "
 516                                    "insert a \'nop\' before the destination address", address);
 517                            }
 518                         } else {
 519                            // This jump is in the current 256 byte page
 520                            if((eval - 2) % 4) {
 521                               warni("* \'jr\' at $%08X - destination address not aligned for short page jump, "
 522                                    "insert a \'nop\' before the destination address", address);
 523                            }
 524                         }
 525                      }
 526                   }
 527                   if((reg2 < -16) || (reg2 > 15)) {
 528                      error("relative jump out of range");
 529                      break;
 530                   }
 531                   *locp = (char)(*locp | ((reg2 >> 3) & 0x03));
 532                   locp++;
 533                   *locp = (char)(*locp | ((reg2 & 0x07) << 5));
 534                   break;
 535                }
 536                if((w & 0x0F00) == FU_NUM15) {
 537                   if(eval < -16 || eval > 15) {
 538                      error("constant out of range");
 539                      break;
 540                   }
 541                   *locp = (char)(*locp | ((eval >> 3) & 0x03));
 542                   locp++;
 543                   *locp = (char)(*locp | ((eval & 0x07) << 5));
 544                   break;
 545                }
 546                if((w & 0x0F00) == FU_NUM31) {
 547                   if(eval < 0 || eval > 31) {
 548                      error("constant out of range");
 549                      break;
 550                   }
 551                   *locp = (char)(*locp | ((eval >> 3) & 0x03));
 552                   locp++;
 553                   *locp = (char)(*locp | ((eval & 0x07) << 5));
 554                   break;
 555                }
 556                if((w & 0x0F00) == FU_NUM32) {
 557                   if(eval < 1 || eval > 32) {
 558                      error("constant out of range");
 559                      break;
 560                   }
 561                   if(w & FU_SUB32)
 562                      eval = (32 - eval);
 563                   eval = (eval == 32) ? 0 : eval;
 564                   *locp = (char)(*locp | ((eval >> 3) & 0x03));
 565                   locp++;
 566                   *locp = (char)(*locp | ((eval & 0x07) << 5));
 567                   break;
 568                }
 569                if((w & 0x0F00) == FU_REGONE) {
 570                   if(eval < 0 || eval > 31) {
 571                      error("register value out of range");
 572                      break;
 573                   }
 574                   *locp = (char)(*locp | ((eval >> 3) & 0x03));
 575                   locp++;
 576                   *locp = (char)(*locp | ((eval & 0x07) << 5));
 577                   break;
 578                }
 579                if((w & 0x0F00) == FU_REGTWO) {
 580                   if(eval < 0 || eval > 31) {
 581                      error("register value out of range");
 582                      break;
 583                   }
 584                   locp++;
 585                   *locp = (char)(*locp | (eval & 0x1F));
 586                   break;
 587                }
 588
 589                if(!(eattr & DEFINED)) {
 590                   if(w & FU_PCREL)
 591                      w = MPCREL | MWORD;
 592                   else w = MWORD;
 593                   rmark(sno, loc, 0, w, esym);
 594                } else {
 595                   if(tdb)
 596                      rmark(sno, loc, tdb, MWORD, NULL);
 597                   if(w & FU_SEXT) {
 598                      if(eval + 0x10000 >= 0x20000)
 599                         goto range;
 600                   } else
 601                      if(w & FU_ISBRA) {                     // Range-check BRA and DBRA
 602                         if(eval + 0x8000 >= 0x10000)
 603                            goto range;
 604                      } else
 605                         if(eval >= 0x10000)
 606                            goto range;
 607                }
 608
 609                *locp++ = (char)(eval >> 8);
 610                *locp = (char)eval;
 611                break;
 612             // Fixup LONG forward references;
 613             // the long could be unaligned in the section buffer, so be careful (again).
 614             case FU_LONG:
 615                if((w & 0x0F00) == FU_MOVEI) {
 616                   address = loc + 4;
 617                   if(eattr & DEFINED) {
 618                      for(j = 0; j < fwindex; j++) {
 619                         if(fwdjump[j] == address) {
 620                            page_jump = (address & 0xFFFFFF00) - (eval & 0xFFFFFF00);
 621                            if(page_jump) {
 622                               if(eval % 4) {
 623                                  err_setup();
 624                                  sprintf(buf, "* \'jump\' at $%08X - destination address not aligned for long page jump, "
 625                                          "insert a \'nop\' before the destination address", address);
 626                                  if(listing > 0) ship_ln(buf);
 627                                  if(err_flag) write(err_fd, buf, (LONG)strlen(buf));
 628                                  else printf("%s\n", buf);
 629                               }
 630                            } else {
 631                               if(!(eval & 0x0000000F) || ((eval - 2) % 4)) {
 632                                  err_setup();
 633                                  sprintf(buf, "* \'jump\' at $%08X - destination address not aligned for short page jump, "
 634                                          "insert a \'nop\' before the destination address", address);
 635                                  if(listing > 0) ship_ln(buf);
 636                                  if(err_flag) write(err_fd, buf, (LONG)strlen(buf));
 637                                  else printf("%s\n", buf);
 638                               }
 639                            }
 640                            // Clear this jump as it has been checked
 641                            fwdjump[j] = 0;
 642                            j = fwindex;
 643                         }
 644                      }
 645                   }
 646                   eval = ((eval >> 16) & 0x0000FFFF) | ((eval << 16) & 0xFFFF0000);
 647                   flags = (MLONG|MMOVEI);
 648                } else flags = MLONG;
 649                if(!(eattr & DEFINED)) {
 650                   rmark(sno, loc, 0, flags, esym);
 651                }
 652                else if(tdb) {
 653                   rmark(sno, loc, tdb, flags, NULL);
 654                }
 655                *locp++ = (char)(eval >> 24);
 656                *locp++ = (char)(eval >> 16);
 657                *locp++ = (char)(eval >> 8);
 658                *locp = (char)eval;
 659                break;
 660             // Fixup a 3-bit "QUICK" reference in bits 9..1
 661             // (range of 1..8) in a word.  Really bits 1..3 in a byte.
 662             case FU_QUICK:
 663                if(!(eattr & DEFINED)) {
 664                   error("External quick reference");
 665                   continue;
 666                }
 667
 668                if(eval < 1 || eval > 8)
 669                   goto range;
 670                *locp |= (eval & 7) << 1;
 671                break;
 672             // Fix up 6502 funny branch
 673             case FU_6BRA:
 674                eval -= (loc + 1);
 675                if(eval + 0x80 >= 0x100)
 676                   goto range;
 677                *locp = (char)eval;
 678                break;
 679             default:
 680                interror(4);                                 // Bad fixup type
 681                // NOTREACHED
 682          }
 683          continue;
 684
 685          range:
 686
 687          error("expression out of range");
 688       }
 689
 690       ch = ch->chnext;
 691    } while(ch != NULL);
 692
 693    return(0);
 694 }