+int ResolveFixups(int sno)
+{
+ SECT * sc = §[sno];
+
+ // "Cache" first chunk
+ CHUNK * cch = sc->sfcode;
+
+ // Can't fixup a section with nothing in it
+ if (cch == NULL)
+ return 0;
+
+ // Wire the 6502 segment's size to its allocated size (64K)
+ if (sno == M6502)
+ cch->ch_size = cch->challoc;
+
+ // Get first fixup for the passed in section
+ FIXUP * fixup = sect[sno].sffix;
+
+ while (fixup != NULL)
+ {
+ // We do it this way because we have continues everywhere... :-P
+ FIXUP * fup = fixup;
+ fixup = fixup->next;
+
+ uint32_t dw = fup->attr; // Fixup long (type + modes + flags)
+ uint32_t loc = fup->loc; // Location to fixup
+ cfileno = fup->fileno;
+ curlineno = fup->lineno;
+ 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); }
+
+ // This is based on global vars cfileno, curfname :-P
+ // This approach is kinda meh as well. I think we can do better
+ // than this.
+ SetFilenameForErrorReporting();
+
+ if ((sno == M56001P) || (sno == M56001X) || (sno == M56001Y) || (sno == M56001L))
+ loc = fup->orgaddr;
+
+ // Search for chunk containing location to fix up; compute a
+ // pointer to the location (in the chunk). Often we will find the
+ // Fixup is in the "cached" chunk, so the linear-search is seldom
+ // executed.
+ if (loc < cch->chloc || loc >= (cch->chloc + cch->ch_size))
+ {
+ for(cch=sc->sfcode; cch!=NULL; cch=cch->chnext)
+ {
+ if (loc >= cch->chloc && loc < (cch->chloc + cch->ch_size))
+ break;
+ }
+
+ if (cch == NULL)
+ {
+ // Fixup (loc) is out of range--this should never happen!
+ // Once we call this function, it winds down immediately; it
+ // doesn't return.
+ interror(7);
+ }
+ }
+
+ // Location to fix (in current chunk)
+ // We use the address of the chunk that loc is actually in, then
+ // subtract the chunk's starting location from loc to get the offset
+ // into the current chunk.
+ uint8_t * locp = cch->chptr + (loc - cch->chloc);
+
+ uint16_t eattr = 0; // Expression attrib
+ SYM * esym = NULL; // External symbol involved in expr
+ uint64_t eval; // Expression value
+ uint16_t flags; // Mark flags
+
+ // Compute expression/symbol value and attributes
+
+ // Complex expression
+ if (dw & FU_EXPR)
+ {
+ // evexpr presumably issues the errors/warnings here
+ if (evexpr(fup->expr, &eval, &eattr, &esym) != OK)
+ continue;
+
+ if ((CHECK_OPTS(OPT_PC_RELATIVE)) && (eattr & REFERENCED) && (eattr & DEFINED) && (!(eattr & EQUATED)))
+ {
+ error("relocation not allowed");
+ continue;
+ }
+ }
+ // Simple symbol
+ else
+ {
+ SYM * sy = fup->symbol;
+ eattr = sy->sattr;
+
+ if ((CHECK_OPTS(OPT_PC_RELATIVE)) && (eattr & REFERENCED) && (eattr & DEFINED) && (!(eattr & EQUATED)))
+ {
+ error("relocation not allowed");
+ continue;
+ }
+
+ if (eattr & DEFINED)
+ eval = sy->svalue;
+ else
+ eval = 0;
+
+ // If the symbol is not defined, but global, set esym to sy
+ if ((eattr & (GLOBAL | DEFINED)) == GLOBAL)
+ esym = sy;
+
+ DEBUG { printf(" name: %s, value: $%" PRIX64 "\n", sy->sname, sy->svalue); }
+ }
+
+ uint16_t tdb = eattr & TDB;
+
+ // If the expression/symbol is undefined and no external symbol is
+ // involved, then that's an error.
+ if (!(eattr & DEFINED) && (esym == NULL))
+ {
+ error(undef_error);
+ continue;
+ }
+
+ // Do the fixup
+ //
+ // If a PC-relative fixup is undefined, its value is *not* subtracted
+ // from the location (that will happen in the linker when the external
+ // reference is resolved).
+ //
+ // PC-relative fixups must be DEFINED and either in the same section
+ // (whereupon the subtraction takes place) or ABS (with no subtract).
+ if ((dw & FU_PCREL) || (dw & FU_PCRELX))
+ {
+ if (eattr & DEFINED)
+ {
+ if (tdb == sno)
+ {
+ eval -= loc;
+
+ // In this instruction the PC is located a DWORD away
+ if (dw & FU_PCRELX)
+ eval += 2;
+ }
+ else if (tdb)
+ {
+ // Allow cross-section PCREL fixups in Alcyon mode
+ if (prg_flag || (obj_format == RAW))
+ {
+ switch (tdb)
+ {
+ case TEXT:
+// Shouldn't there be a break here, since otherwise, it will point to the DATA section?
+// break;
+ case DATA:
+ eval += sect[TEXT].sloc;
+ break;
+ case BSS:
+ eval += sect[TEXT].sloc + sect[DATA].sloc;
+ break;
+ default:
+ error("invalid section");
+ break;
+ }
+
+ eval -= loc;
+
+ // In this instruction the PC is located a DWORD away
+ if (dw & FU_PCRELX)
+ eval += 2;
+ }
+ else
+ {
+ error("PC-relative expr across sections");
+ continue;
+ }
+ }
+
+ if (optim_warn_flag && (dw & FU_LBRA) && (eval + 0x80 < 0x100))
+ warn("unoptimized short branch");
+ }
+
+ // Be sure to clear any TDB flags, since we handled it just now
+ tdb = 0;
+ eattr &= ~TDB;
+ }
+
+ // Handle fixup classes
+ switch (dw & FUMASK)
+ {
+ // FU_BBRA fixes up a one-byte branch offset.
+ case FU_BBRA:
+ if (!(eattr & DEFINED))
+ {
+ error("external short branch");
+ continue;
+ }
+
+ eval -= 2;
+
+ if (eval + 0x80 >= 0x100)
+ goto rangeErr;
+
+ if (eval == 0)
+ {
+ if (*locp) // optim_flags[OPT_NULL_BRA] is stored there, check the comment in mach.s under m_br
+ {
+ // Just output a NOP
+ *locp++ = 0x4E;
+ *locp = 0x71;
+
+ if (optim_warn_flag)
+ warn("bra.s with zero offset converted to NOP");
+
+ continue;
+ }
+ else
+ {
+ error("illegal bra.s with zero offset");
+ continue;
+ }
+ }
+
+ *++locp = (uint8_t)eval;
+ break;
+
+ // Fixup one-byte value at locp + 1.
+ case FU_WBYTE:
+ locp++;
+ // FALLTHROUGH
+
+ // Fixup one-byte forward references
+ case FU_BYTE:
+ if (!(eattr & DEFINED))
+ {
+ error("external byte reference");
+ continue;
+ }
+
+ if (tdb)
+ {
+ error("non-absolute byte reference");
+ continue;
+ }
+
+ if ((dw & FU_PCREL) && ((eval + 0x80) >= 0x100))
+ goto rangeErr;
+
+ if (dw & FU_SEXT)
+ {
+ if ((eval + 0x100) >= 0x200)
+ goto rangeErr;
+ }
+ else if (eval >= 0x100)
+ goto rangeErr;
+
+ *locp = (uint8_t)eval;
+ break;
+
+ // Fixup high/low byte off word for 6502
+ case FU_BYTEH:
+ if (!(eattr & DEFINED))
+ {
+ error("external byte reference");
+ continue;
+ }
+
+ *locp = (uint8_t)(eval >> 8);
+ break;
+
+ case FU_BYTEL:
+ if (!(eattr & DEFINED))
+ {
+ error("external byte reference");
+ continue;
+ }
+
+ *locp = (uint8_t)eval;
+ break;
+
+ // Fixup WORD forward references; the word could be unaligned in the
+ // section buffer, so we have to be careful. (? careful about what?)
+ case FU_WORD:
+ if ((dw & FUMASKRISC) == FU_JR)
+ {
+ int reg = (signed)((eval - ((fup->orgaddr ? fup->orgaddr : loc) + 2)) / 2);
+
+ if ((reg < -16) || (reg > 15))
+ {
+ error("relative jump out of range");
+ break;
+ }
+
+ *locp |= ((uint8_t)reg >> 3) & 0x03;
+ locp++;
+ *locp |= ((uint8_t)reg & 0x07) << 5;
+ break;
+ }
+ else if ((dw & FUMASKRISC) == FU_NUM15)
+ {
+ if (((int)eval < -16) || ((int)eval > 15))
+ {
+ error("constant out of range (-16 - +15)");
+ break;
+ }
+
+ *locp |= ((uint8_t)eval >> 3) & 0x03;
+ locp++;
+ *locp |= ((uint8_t)eval & 0x07) << 5;
+ break;
+ }
+ else if ((dw & FUMASKRISC) == FU_NUM31)
+ {
+ if (eval > 31)
+ {
+ error("constant out of range (0-31)");
+ break;
+ }
+
+ *locp |= ((uint8_t)eval >> 3) & 0x03;
+ locp++;
+ *locp |= ((uint8_t)eval & 0x07) << 5;
+ break;
+ }
+ else if ((dw & FUMASKRISC) == FU_NUM32)
+ {
+ if ((eval < 1) || (eval > 32))
+ {
+ error("constant out of range (1-32)");
+ break;
+ }
+
+ if (dw & FU_SUB32)
+ eval = (32 - eval);
+
+ eval = (eval == 32) ? 0 : eval;
+ *locp |= ((uint8_t)eval >> 3) & 0x03;
+ locp++;
+ *locp |= ((uint8_t)eval & 0x07) << 5;
+ break;
+ }
+ else if ((dw & FUMASKRISC) == FU_REGONE)
+ {
+ if (eval > 31)
+ {
+ error("register one value out of range");
+ break;
+ }
+
+ *locp |= ((uint8_t)eval >> 3) & 0x03;
+ locp++;
+ *locp |= ((uint8_t)eval & 0x07) << 5;
+ break;
+ }
+ else if ((dw & FUMASKRISC) == FU_REGTWO)
+ {
+ if (eval > 31)
+ {
+ error("register two value out of range");
+ break;
+ }
+
+ locp++;
+ *locp |= (uint8_t)eval & 0x1F;
+ break;
+ }
+
+ if (!(eattr & DEFINED))
+ {
+ flags = MWORD;
+
+ if (dw & FU_PCREL)
+ flags |= MPCREL;
+
+ MarkRelocatable(sno, loc, 0, flags, esym);
+ }
+ else
+ {
+ if (tdb)
+ MarkRelocatable(sno, loc, tdb, MWORD, NULL);
+
+ if (dw & FU_SEXT)
+ {
+ if (eval + 0x10000 >= 0x20000)
+ goto rangeErr;
+ }
+ else
+ {
+ // Range-check BRA and DBRA
+ if (dw & FU_ISBRA)
+ {
+ if (eval + 0x8000 >= 0x10000)
+ goto rangeErr;
+ }
+ else if (eval >= 0x10000)
+ goto rangeErr;
+ }
+ }
+
+ // 6502 words are little endian, so handle that here
+ if (sno == M6502)
+ SETLE16(locp, 0, eval)
+ else
+ SETBE16(locp, 0, eval)
+
+ break;
+
+ // Fixup LONG forward references; the long could be unaligned in the
+ // section buffer, so be careful (again).
+ case FU_LONG:
+ flags = MLONG;
+
+ if ((dw & FUMASKRISC) == FU_MOVEI)
+ {
+ // Long constant in MOVEI # is word-swapped, so fix it here
+ eval = WORDSWAP32(eval);
+ flags |= MMOVEI;
+ }
+
+ // If the symbol is undefined, make sure to pass the symbol in
+ // to the MarkRelocatable() function.
+ if (!(eattr & DEFINED))
+ MarkRelocatable(sno, loc, 0, flags, esym);
+ else if (tdb)
+ MarkRelocatable(sno, loc, tdb, flags, NULL);
+
+ SETBE32(locp, 0, eval);
+ break;
+
+ // Fixup QUAD forward references (mainly used by the OP assembler)
+ case FU_QUAD:
+ if (dw & FU_OBJLINK)
+ {
+ uint64_t quad = GETBE64(locp, 0);
+ uint64_t addr = eval;
+
+//Hmm, not sure how this can be set, since it's only set if it's a DSP56001 fixup or a FU_JR... :-/
+// if (fup->orgaddr)
+// addr = fup->orgaddr;
+
+ eval = (quad & 0xFFFFFC0000FFFFFFLL) | ((addr & 0x3FFFF8) << 21);
+ }
+ else if (dw & FU_OBJDATA)
+ {
+ // If it's in a TEXT or DATA section, be sure to mark for a
+ // fixup later
+ if (tdb)
+ MarkRelocatable(sno, loc, tdb, MQUAD, NULL);
+
+ uint64_t quad = GETBE64(locp, 0);
+ uint64_t addr = eval;
+
+//Hmm, not sure how this can be set, since it's only set if it's a DSP56001 fixup or a FU_JR... :-/
+// if (fup->orgaddr)
+// addr = fup->orgaddr;
+
+ eval = (quad & 0x000007FFFFFFFFFFLL) | ((addr & 0xFFFFF8) << 40);
+ }
+
+ SETBE64(locp, 0, eval);
+ break;
+
+ // Fixup a 3-bit "QUICK" reference in bits 9..1
+ // (range of 1..8) in a word. [Really bits 1..3 in a byte.]
+ case FU_QUICK:
+ if (!(eattr & DEFINED))
+ {
+ error("External quick reference");
+ continue;
+ }
+
+ if ((eval < 1) || (eval > 8))
+ goto rangeErr;
+
+ *locp |= (eval & 7) << 1;
+ break;
+
+ // Fix up 6502 funny branch
+ case FU_6BRA:
+ eval -= (loc + 1);
+
+ if (eval + 0x80 >= 0x100)
+ goto rangeErr;
+
+ *locp = (uint8_t)eval;
+ break;
+
+ // Fixup DSP56001 addresses
+ case FU_56001:
+ switch (dw & FUMASKDSP)
+ {
+ // DSPIMM5 actually is clamped from 0 to 23 for our purposes
+ // and does not use the full 5 bit range.
+ case FU_DSPIMM5:
+ if (eval > 23)
+ {
+ error("immediate value must be between 0 and 23");
+ break;
+ }
+
+ locp[2] |= eval;
+ break;
+
+ // This is a 12-bit address encoded into the lower 12
+ // bits of a DSP word
+ case FU_DSPADR12:
+ if (eval >= 0x1000)
+ {
+ error("address out of range ($0-$FFF)");
+ break;
+ }
+
+ locp[1] |= eval >> 8;
+ locp[2] = eval & 0xFF;
+ break;
+
+ // This is a full DSP word containing Effective Address Extension
+ case FU_DSPADR24:
+ case FU_DSPIMM24:
+ if (eval >= 0x1000000)
+ {
+ error("value out of range ($0-$FFFFFF)");
+ break;
+ }
+
+ locp[0] = (uint8_t)((eval >> 16) & 0xFF);
+ locp[1] = (uint8_t)((eval >> 8) & 0xFF);
+ locp[2] = (uint8_t)(eval & 0xFF);
+ break;
+
+ // This is a 16bit absolute address into a 24bit field
+ case FU_DSPADR16:
+ if (eval >= 0x10000)
+ {
+ error("address out of range ($0-$FFFF)");
+ break;
+ }
+
+ locp[1] = (uint8_t)(eval >> 8);
+ locp[2] = (uint8_t)eval;
+ break;
+
+ // This is 12-bit immediate short data
+ // The upper nibble goes into the last byte's low nibble
+ // while the remainder 8 bits go into the 2nd byte.
+ case FU_DSPIMM12:
+ if (eval >= 0x1000)
+ {
+ error("immediate out of range ($0-$FFF)");
+ break;
+ }
+
+ locp[1] = (uint8_t)eval;
+ locp[2] |= (uint8_t)(eval >> 8);
+ break;
+
+ // This is 8-bit immediate short data
+ // which goes into the middle byte of a DSP word.
+ case FU_DSPIMM8:
+ if (eval >= 0x100)
+ {
+ error("immediate out of range ($0-$FF)");
+ break;
+ }
+
+ locp[1] = (uint8_t)eval;
+ break;
+
+ // This is a 6 bit absoulte short address. It occupies the low 6
+ // bits of the middle byte of a DSP word.
+ case FU_DSPADR06:
+ if (eval > 63)
+ {
+ error("address must be between 0 and 63");
+ break;
+ }
+
+ locp[1] |= eval;
+ break;
+
+ // This is a 6 bit absoulte short address. It occupies the low 6
+ // bits of the middle byte of a DSP word.
+ case FU_DSPPP06:
+ if (eval < 0xFFFFFFC0)
+ {
+ error("address must be between $FFC0 and $FFFF");
+ break;
+ }
+
+ locp[1] |= eval & 0x3F;
+ break;
+
+ // Shamus: I'm pretty sure these don't make any sense...
+ case FU_DSPIMMFL8:
+ warn("FU_DSPIMMFL8 missing implementation\n%s", "And you may ask yourself, \"Self, how did I get here?\"");
+ break;
+
+ case FU_DSPIMMFL16:
+ warn("FU_DSPIMMFL16 missing implementation\n%s", "And you may ask yourself, \"Self, how did I get here?\"");
+ break;
+
+ case FU_DSPIMMFL24:
+ warn("FU_DSPIMMFL24 missing implementation\n%s", "And you may ask yourself, \"Self, how did I get here?\"");
+ break;
+
+ // Bad fixup type--this should *never* happen!
+ default:
+ interror(4);
+ // NOTREACHED
+ }
+ break;
+
+ // Fixup a 4-byte float
+ case FU_FLOATSING:
+ warn("FU_FLOATSING missing implementation\n%s", "And you may ask yourself, \"Self, how did I get here?\"");
+ break;
+
+ // Fixup a 8-byte float
+ case FU_FLOATDOUB:
+ warn("FU_FLOATDOUB missing implementation\n%s", "And you may ask yourself, \"Self, how did I get here?\"");
+ break;
+
+ // Fixup a 12-byte float
+ case FU_FLOATEXT:
+ warn("FU_FLOATEXT missing implementation\n%s", "And you may ask yourself, \"Self, how did I get here?\"");
+ break;
+
+ default:
+ // Bad fixup type--this should *never* happen!
+ // Once we call this function, it winds down immediately; it
+ // doesn't return.
+ interror(4);
+ }
+
+ continue;
+rangeErr:
+ error("expression out of range");
+ }
+
+ return 0;