X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?p=rmac;a=blobdiff_plain;f=sect.c;h=b5bd6ecfb04673eccb44fa7cb768da51735f90eb;hp=21591a0219146b127a7321dbd07dcea4cab0ba1f;hb=05d0350b35a6a6b255cb2a3fab7796f5d4ee4d02;hpb=9fb8931331db981c04e062a3ad36c0d79acb30ae diff --git a/sect.c b/sect.c index 21591a0..b5bd6ec 100644 --- a/sect.c +++ b/sect.c @@ -1,77 +1,103 @@ // -// RMAC - Reboot's Macro Assembler for the Atari Jaguar Console System +// RMAC - Reboot's Macro Assembler for all Atari computers // SECT.C - Code Generation, Fixups and Section Management -// Copyright (C) 199x Landon Dyer, 2011 Reboot and Friends +// Copyright (C) 199x Landon Dyer, 2011-2017 Reboot and Friends // RMAC derived from MADMAC v1.07 Written by Landon Dyer, 1986 -// Source Utilised with the Kind Permission of Landon Dyer +// Source utilised with the kind permission of Landon Dyer // #include "sect.h" +#include "6502.h" #include "direct.h" #include "error.h" #include "expr.h" #include "listing.h" #include "mach.h" #include "mark.h" -#include "risca.h" +#include "riscasm.h" #include "symbol.h" #include "token.h" +// Minimum size of a fixup record +#define MIN_FIXUP_MEM (3 * sizeof(uint16_t) + 1 * sizeof(uint32_t)) + +// Function prototypes +void MakeSection(int, uint16_t); +void SwitchSection(int); + // Section descriptors -SECT sect[NSECTS]; // All sections... -int cursect; // Current section number +SECT sect[NSECTS]; // All sections... +int cursect; // Current section number // These are copied from the section descriptor, the current code chunk // descriptor and the current fixup chunk descriptor when a switch is made into // a section. They are copied back to the descriptors when the section is left. -WORD scattr; // Section attributes -LONG sloc; // Current loc in section +uint16_t scattr; // Section attributes +uint32_t sloc; // Current loc in section -CHUNK * scode; // Current (last) code chunk -LONG challoc; // # bytes alloc'd to code chunk -LONG ch_size; // # bytes used in code chunk -char * chptr; // Deposit point in code chunk buffer +CHUNK * scode; // Current (last) code chunk +uint32_t challoc; // # bytes alloc'd to code chunk +uint32_t ch_size; // # bytes used in code chunk +uint8_t * chptr; // Deposit point in code chunk buffer +uint8_t * chptr_opcode; // Backup of chptr, updated before entering code generators -CHUNK * sfix; // Current (last) fixup chunk -LONG fchalloc; // # bytes alloc'd to fixup chunk -LONG fchsize; // # bytes used in fixup chunk -PTR fchptr; // Deposit point in fixup chunk buffer - -// BOLLOCKS -//unsigned fwdjump[MAXFWDJUMPS]; // forward jump check table -//unsigned fwindex = 0; // forward jump index +CHUNK * sfix; // Current (last) fixup chunk +uint32_t fchalloc; // # bytes alloc'd to fixup chunk +uint32_t fchsize; // # bytes used in fixup chunk +PTR fchptr; // Deposit point in fixup chunk buffer // Return a size (SIZB, SIZW, SIZL) or 0, depending on what kind of fixup is // associated with a location. -static char fusiztab[] = { - 0, // FU_QUICK - 1, // FU_BYTE - 2, // FU_WORD - 2, // FU_WBYTE - 4, // FU_LONG - 1, // FU_BBRA - 0, // (unused) - 1, // FU_6BRA +static uint8_t fusiztab[] = { + 0, // FU_QUICK + 1, // FU_BYTE + 2, // FU_WORD + 2, // FU_WBYTE + 4, // FU_LONG + 1, // FU_BBRA + 0, // (unused) + 1, // FU_6BRA }; // Offset to REAL fixup location -static char fusizoffs[] = { - 0, // FU_QUICK - 0, // FU_BYTE - 0, // FU_WORD - 1, // FU_WBYTE - 0, // FU_LONG - 1, // FU_BBRA - 0, // (unused) - 0, // FU_6BRA +static uint8_t fusizoffs[] = { + 0, // FU_QUICK + 0, // FU_BYTE + 0, // FU_WORD + 1, // FU_WBYTE + 0, // FU_LONG + 1, // FU_BBRA + 0, // (unused) + 0, // FU_6BRA }; // -// Make a New (Clean) Section +// Initialize sections; setup initial ABS, TEXT, DATA and BSS sections +// +void InitSection(void) +{ + // Cleanup all sections + for(int i=0; iscattr = attr; @@ -82,16 +108,19 @@ void mksect(int sno, WORD attr) // -// Switch to Another Section (Copy Section & Chunk Descriptors to Global Vars -// for Fast Access) +// Switch to another section (copy section & chunk descriptors to global vars +// for fast access) // -void switchsect(int sno) +void SwitchSection(int sno) { - CHUNK * cp; // Chunk pointer + CHUNK * cp; cursect = sno; SECT * p = §[sno]; - scattr = p->scattr; // Copy section vars + m6502 = (sno == M6502); // Set 6502-mode flag + + // Copy section vars + scattr = p->scattr; sloc = p->sloc; scode = p->scode; sfix = p->sfix; @@ -102,11 +131,15 @@ void switchsect(int sno) challoc = cp->challoc; ch_size = cp->ch_size; chptr = cp->chptr + ch_size; + + // For 6502 mode, add the last org'd address + if (m6502) + chptr = cp->chptr + orgaddr; } else challoc = ch_size = 0; - // Copy fixup chunk vars + // Copy fixup chunk vars if ((cp = sfix) != NULL) { fchalloc = cp->challoc; @@ -119,9 +152,9 @@ void switchsect(int sno) // -// Save Current Section +// Save current section // -void savsect(void) +void SaveSection(void) { SECT * p = §[cursect]; @@ -136,54 +169,29 @@ void savsect(void) } -// -// Initialize Sections; Setup initial ABS, TEXT, DATA and BSS sections -// -void init_sect(void) -{ - int i; - - // Cleanup all sections - for(i=0; ichnext) + // Hairy, ugly linear search for a mark on our location; the speed doesn't + // matter, since this is only done when generating a listing, which is + // SLOW. + for(CHUNK * ch=sect[sno].sffix; ch!=NULL; ch=ch->chnext) { - fup.cp = (char *)ch->chptr; - fuend = fup.cp + ch->ch_size; + fup.cp = (uint8_t *)ch->chptr; + uint8_t * fuend = fup.cp + ch->ch_size; while (fup.cp < fuend) { - w = *fup.wp++; - xloc = *fup.lp++ + (int)fusizoffs[w & FUMASK]; + uint16_t w = *fup.wp++; + uint32_t xloc = *fup.lp++ + (int)fusizoffs[w & FUMASK]; fup.wp += 2; if (xloc == loc) @@ -195,7 +203,7 @@ int fixtest(int sno, LONG loc) fup.lp += w; } else - ++fup.lp; + fup.lp++; } } @@ -203,14 +211,14 @@ int fixtest(int sno, LONG loc) } -// -// Check that there are at least `amt' bytes left in the current chunk. If -// there are not, allocate another chunk of at least `amt' bytes (and probably +// +// Check that there are at least 'amt' bytes left in the current chunk. If +// there are not, allocate another chunk of at least 'amt' bytes (and probably // more). -// -// If `amt' is zero, ensure there are at least CH_THRESHOLD bytes, likewise. // -int chcheck(LONG amt) +// If 'amt' is zero, ensure there are at least CH_THRESHOLD bytes, likewise. +// +int chcheck(uint32_t amt) { DEBUG { printf("chcheck(%u)\n", amt); } // If in BSS section, no allocation required @@ -221,7 +229,7 @@ int chcheck(LONG amt) amt = CH_THRESHOLD; DEBUG { printf(" challoc=%i, ch_size=%i, diff=%i\n", challoc, ch_size, challoc-ch_size); } - if ((int)(challoc - ch_size) >= (int)amt) + if ((int)(challoc - ch_size) >= (int)amt) return 0; if (amt < CH_CODE_SIZE) @@ -242,7 +250,7 @@ int chcheck(LONG amt) { cp->chprev = scode; scode->chnext = cp; - scode->ch_size = ch_size; // Save old chunk's globals + scode->ch_size = ch_size; // Save old chunk's globals } // Setup chunk and global vars @@ -250,68 +258,71 @@ int chcheck(LONG amt) cp->chnext = NULL; challoc = cp->challoc = amt; ch_size = cp->ch_size = 0; - chptr = cp->chptr = ((char *)cp) + sizeof(CHUNK); + chptr = cp->chptr = ((uint8_t *)cp) + sizeof(CHUNK); scode = p->scode = cp; return 0; } -// This is really wrong. We need to make some proper structures here so we don't -// have to count sizes of objects, that's what the compiler's for! :-P -#define FIXUP_BASE_SIZE (sizeof(WORD) + sizeof(LONG) + sizeof(WORD) + sizeof(WORD)) +// +// A fixup record is at least 4 pieces of data long, with some optional data at +// the end. Is of the form: +// +// SYMBOL EXPRESSION +// ------ ---------- +// FU_EXPR.W FU_EXPR.W fixup type +// loc.L loc.L location in section +// fileno.W fileno.W file number fixup occurred in +// lineno.W lineno.W line number fixup occurred in +// symbol.* size.W &symbol (32 or 64 bits) / size of expression +// token.L size (zero or more) TOKENS (32-bits each) +// ENDEXPR.L End of expression (with size > zero) +// JR.L Possible ORG address of RISC JR instruction // // Arrange for a fixup on a location // -int fixup(WORD attr, LONG loc, TOKEN * fexpr) +int AddFixup(uint16_t attr, uint32_t loc, TOKEN * fexpr) { - LONG i; - LONG len = 0; - CHUNK * cp; - SECT * p; - // Shamus: Expression lengths are voodoo ATM (varibale "i"). Need to fix this. -#warning "!!! fixup() is filled with VOODOO !!!" + uint32_t i = MIN_FIXUP_MEM; + uint16_t len = 0; + DEBUG printf("FIXUP@$%X: $%X\n", loc, attr); // Compute length of expression (could be faster); determine if it's the - // single-symbol case; no expression if it's just a mark. This code assumes - // 16 bit WORDs and 32 bit LONGs - if (*fexpr == SYMBOL && fexpr[2] == ENDEXPR) + // single-symbol case; no expression if it's just a mark. (? is this true?) + if ((*fexpr == SYMBOL) && (fexpr[2] == ENDEXPR)) { - // Just a single symbol - // SCPCD : correct bit mask for attr (else other FU_xxx will match) NYAN ! - if ((attr & 0x0F00) == FU_JR) - { -// i = 18; -// i = FIXUP_BASE_SIZE + (sizeof(LONG) * 2); - i = FIXUP_BASE_SIZE + sizeof(SYM *) + sizeof(LONG); - } - else - { -// i = 14; - i = FIXUP_BASE_SIZE + sizeof(SYM *); - } + // Just a single symbol, possibly followed by a DWORD + i += sizeof(SYM *); + + // SCPCD: Correct bit mask for attr (else other FU_xxx will match) + // NYAN ! + if ((attr & FUMASKRISC) == FU_JR) + i += sizeof(uint32_t); } else { attr |= FU_EXPR; + // Count the # of tokens in the expression for(len=0; fexpr[len]!=ENDEXPR; len++) { + // Add one to len for 2X tokens if (fexpr[len] == CONST || fexpr[len] == SYMBOL) len++; } - len++; // Add 1 for ENDEXPR -// i = (len << 2) + 12; - i = FIXUP_BASE_SIZE + sizeof(WORD) + (len * sizeof(TOKEN)); + // Add 1 for ENDEXPR + len++; + i += sizeof(uint16_t) + (len * sizeof(TOKEN)); } - // Maybe alloc another fixup chunk for this one to fit in + // Alloc another fixup chunk for this one to fit in if necessary if ((fchalloc - fchsize) < i) { - p = §[cursect]; - cp = (CHUNK *)malloc(sizeof(CHUNK) + CH_FIXUP_SIZE); + SECT * p = §[cursect]; + CHUNK * cp = (CHUNK *)malloc(sizeof(CHUNK) + CH_FIXUP_SIZE); // First fixup chunk in section if (sfix == NULL) @@ -331,7 +342,7 @@ int fixup(WORD attr, LONG loc, TOKEN * fexpr) cp->chnext = NULL; fchalloc = cp->challoc = CH_FIXUP_SIZE; fchsize = cp->ch_size = 0; - fchptr.cp = cp->chptr = ((char *)cp) + sizeof(CHUNK); + fchptr.cp = cp->chptr = ((uint8_t *)cp) + sizeof(CHUNK); sfix = p->sfix = cp; } @@ -340,136 +351,89 @@ int fixup(WORD attr, LONG loc, TOKEN * fexpr) *fchptr.wp++ = attr; *fchptr.lp++ = loc; *fchptr.wp++ = cfileno; - *fchptr.wp++ = (WORD)curlineno; + *fchptr.wp++ = curlineno; // Store postfix expression or pointer to a single symbol, or nothing for a - // mark. + // mark (a zero word is stored in this case--[? is it?]). if (attr & FU_EXPR) { - *fchptr.wp++ = (WORD)len; + *fchptr.wp++ = len; while (len--) - *fchptr.lp++ = (LONG)*fexpr++; + *fchptr.lp++ = *fexpr++; } else { -// *fchptr.lp++ = (LONG)fexpr[1]; *fchptr.sy++ = symbolPtr[fexpr[1]]; - } - - // SCPCD : correct bit mask for attr (else other FU_xxx will match) NYAN ! - if ((attr & 0x0F00) == FU_JR) - { - if (orgactive) - *fchptr.lp++ = orgaddr; - else - *fchptr.lp++ = 0x00000000; - } - - fchsize += i; - return 0; -} - -// -// Resolve all Fixups -// -int ResolveAllFixups(void) -{ - unsigned i; - char buf[EBUFSIZ]; - - // Make undefined symbols GLOBL - if (glob_flag) - syg_fix(); - - DEBUG printf("Resolving TEXT sections...\n"); - ResolveFixups(TEXT); - DEBUG printf("Resolving DATA sections...\n"); - ResolveFixups(DATA); - -//No, no we don't. -#if 0 - // We need to do a final check of forward 'jump' destination addresses that - // are external - for(i=0; i 0) - ship_ln(buf); - - if (err_flag) - write(err_fd, buf, (LONG)strlen(buf)); + if (orgactive) + *fchptr.lp++ = orgaddr; else - printf("%s\n", buf); + *fchptr.lp++ = 0x00000000; } } -#endif + fchsize += i; return 0; } // -// Resolve Fixups in a Section +// Resolve fixups in a section // int ResolveFixups(int sno) { - PTR fup; // Current fixup - WORD * fuend; // End of last fixup (in this chunk) - WORD w; // Fixup word (type+modes+flags) - char * locp; // Location to fix (in cached chunk) - LONG loc; // Location to fixup - VALUE eval; // Expression value - WORD eattr; // Expression attrib - SYM * esym; // External symbol involved in expr - SYM * sy; // (Temp) pointer to a symbol - WORD i; // (Temp) word - WORD tdb; // eattr & TDB - LONG oaddr; + PTR fup; // Current fixup + VALUE eval; // Expression value + SYM * sy; // (Temp) pointer to a symbol + uint16_t i; // (Temp) word int reg2; - WORD flags; - unsigned page_jump = 0; - unsigned address = 0; - unsigned j; - char buf[EBUFSIZ]; - + uint16_t flags; + SECT * sc = §[sno]; CHUNK * ch = sc->sffix; if (ch == NULL) return 0; - CHUNK * cch = sc->sfcode; // "cache" first chunk + // "Cache" first chunk + CHUNK * cch = sc->sfcode; - if (cch == NULL) // Can't fixup a sect with nothing in it + // 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; + do { fup.cp = ch->chptr; // fup -> start of chunk - fuend = (WORD *)(fup.cp + ch->ch_size); // fuend -> end of chunk + uint16_t * fuend = (uint16_t *)(fup.cp + ch->ch_size); // fuend -> end of chunk while (fup.wp < fuend) { - w = *fup.wp++; - loc = *fup.lp++; + uint16_t w = *fup.wp++; // Fixup word (type+modes+flags) + uint32_t loc = *fup.lp++; // Location to fixup cfileno = *fup.wp++; - curlineno = (int)*fup.wp++; -DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); } + curlineno = *fup.wp++; + DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); } + // This is based on global vars cfileno, curfname :-P - // This approach is kinda meh as well. I think we can do better than this. + // This approach is kinda meh as well. I think we can do better + // than this. SetFilenameForErrorReporting(); - esym = NULL; + SYM * esym = NULL; // External symbol involved in expr // 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 + // Fixup is in the "cached" chunk, so the linear-search is seldom // executed. if (loc < cch->chloc || loc >= (cch->chloc + cch->ch_size)) { @@ -481,15 +445,18 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); } if (cch == NULL) { - interror(7); // Fixup (loc) out of range + // Fixup (loc) out of range + interror(7); // NOTREACHED } } - locp = cch->chptr + (loc - cch->chloc); - eattr = 0; + // Location to fix (in cached chunk) + uint8_t * locp = cch->chptr + (loc - cch->chloc); + uint16_t eattr = 0; // Expression attrib // Compute expression/symbol value and attribs + // Complex expression if (w & FU_EXPR) { @@ -514,33 +481,31 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); } else eval = 0; + // If the symbol is not defined, but global, set esym to sy if ((eattr & (GLOBAL | DEFINED)) == GLOBAL) esym = sy; } - tdb = (WORD)(eattr & TDB); + uint16_t tdb = eattr & TDB; // If the expression is undefined and no external symbol is - // involved, then it's an error. - if (!(eattr & DEFINED) && esym == NULL) + // involved, then that's an error. + if (!(eattr & DEFINED) && (esym == NULL)) { error(undef_error); continue; } - if (((w & 0x0F00) == FU_MOVEI) && esym) - esym->sattre |= RISCSYM; - // 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). - // + // // MWC expects PC-relative things to have the LOC subtracted from // the value, if the value is external (that is, undefined at this // point). - // + // // PC-relative fixups must be DEFINED and either in the same // section (whereupon the subtraction takes place) or ABS (with no // subtract). @@ -567,7 +532,7 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); } } // Do fixup classes - switch ((int)(w & FUMASK)) + switch (w & FUMASK) { // FU_BBRA fixes up a one-byte branch offset. case FU_BBRA: @@ -580,7 +545,7 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); } eval -= 2; if (eval + 0x80 >= 0x100) - goto range; + goto rangeErr; if (eval == 0) { @@ -588,7 +553,7 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); } continue; } - *++locp = (char)eval; + *++locp = (uint8_t)eval; break; // Fixup one-byte value at locp + 1. case FU_WBYTE: @@ -609,69 +574,49 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); } } if ((w & FU_PCREL) && eval + 0x80 >= 0x100) - goto range; + goto rangeErr; if (w & FU_SEXT) { if (eval + 0x100 >= 0x200) - goto range; + goto rangeErr; } else if (eval >= 0x100) - goto range; + goto rangeErr; - *locp = (char)eval; + *locp = (uint8_t)eval; break; - // Fixup WORD forward references; + // Fixup high/low byte off word for 6502 + case FU_BYTEH: + if (!(eattr & DEFINED)) + { + error("external byte reference"); + continue; + } + + *locp = (uint8_t)((eval >> 8) & 0xFF); + break; + case FU_BYTEL: + if (!(eattr & DEFINED)) + { + error("external byte reference"); + continue; + } + + *locp = (uint8_t)(eval & 0xFF); + break; + // Fixup WORD forward references; // the word could be unaligned in the section buffer, so we have to // be careful. case FU_WORD: - if ((w & 0x0F00) == FU_JR)// || ((w & 0x0F00) == FU_MJR)) + if ((w & FUMASKRISC) == FU_JR) { - oaddr = *fup.lp++; + uint32_t orgaddr = *fup.lp++; - if (oaddr) - reg2 = (signed)((eval - (oaddr + 2)) / 2);// & 0x1F; + if (orgaddr) + reg2 = (signed)((eval - (orgaddr + 2)) / 2); else - reg2 = (signed)((eval - (loc + 2)) / 2);// & 0x1F; - -#if 0 - if ((w & 0x0F00) == FU_MJR) - { - // Main code destination alignment checking here for - // forward declared labels - address = (oaddr) ? oaddr : loc; - - if (((address >= 0xF03000) && (address < 0xF04000) - && (eval < 0xF03000)) || ((eval >= 0xF03000) - && (eval < 0xF04000) && (address < 0xF03000))) - { - warni("* \'jr\' at $%08X - cannot jump relative between " - "main memory and local gpu ram", address); - } - else - { - page_jump = (address & 0xFFFFFF00) - (eval & 0xFFFFFF00); - - if (page_jump) - { - // This jump is to a page outside of the - // current 256 byte page - if (eval % 4) - { - warni("* \'jr\' at $%08X - destination address not aligned for long page jump, insert a \'nop\' before the destination address", address); - } - } - else - { - // This jump is in the current 256 byte page - if ((eval - 2) % 4) - { - warni("* \'jr\' at $%08X - destination address not aligned for short page jump, insert a \'nop\' before the destination address", address); - } - } - } - } -#endif + reg2 = (signed)((eval - (loc + 2)) / 2); if ((reg2 < -16) || (reg2 > 15)) { @@ -679,13 +624,13 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); } break; } - *locp = (char)(*locp | ((reg2 >> 3) & 0x03)); + *locp = (uint8_t)(*locp | ((reg2 >> 3) & 0x03)); locp++; - *locp = (char)(*locp | ((reg2 & 0x07) << 5)); + *locp = (uint8_t)(*locp | ((reg2 & 0x07) << 5)); break; } - if ((w & 0x0F00) == FU_NUM15) + if ((w & FUMASKRISC) == FU_NUM15) { if (eval < -16 || eval > 15) { @@ -693,13 +638,13 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); } break; } - *locp = (char)(*locp | ((eval >> 3) & 0x03)); + *locp = (uint8_t)(*locp | ((eval >> 3) & 0x03)); locp++; - *locp = (char)(*locp | ((eval & 0x07) << 5)); + *locp = (uint8_t)(*locp | ((eval & 0x07) << 5)); break; } - if ((w & 0x0F00) == FU_NUM31) + if ((w & FUMASKRISC) == FU_NUM31) { if (eval < 0 || eval > 31) { @@ -707,13 +652,13 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); } break; } - *locp = (char)(*locp | ((eval >> 3) & 0x03)); + *locp = (uint8_t)(*locp | ((eval >> 3) & 0x03)); locp++; - *locp = (char)(*locp | ((eval & 0x07) << 5)); + *locp = (uint8_t)(*locp | ((eval & 0x07) << 5)); break; } - if ((w & 0x0F00) == FU_NUM32) + if ((w & FUMASKRISC) == FU_NUM32) { if (eval < 1 || eval > 32) { @@ -725,13 +670,13 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); } eval = (32 - eval); eval = (eval == 32) ? 0 : eval; - *locp = (char)(*locp | ((eval >> 3) & 0x03)); + *locp = (uint8_t)(*locp | ((eval >> 3) & 0x03)); locp++; - *locp = (char)(*locp | ((eval & 0x07) << 5)); + *locp = (uint8_t)(*locp | ((eval & 0x07) << 5)); break; } - if ((w & 0x0F00) == FU_REGONE) + if ((w & FUMASKRISC) == FU_REGONE) { if (eval < 0 || eval > 31) { @@ -739,13 +684,13 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); } break; } - *locp = (char)(*locp | ((eval >> 3) & 0x03)); + *locp = (uint8_t)(*locp | ((eval >> 3) & 0x03)); locp++; - *locp = (char)(*locp | ((eval & 0x07) << 5)); + *locp = (uint8_t)(*locp | ((eval & 0x07) << 5)); break; } - if ((w & 0x0F00) == FU_REGTWO) + if ((w & FUMASKRISC) == FU_REGTWO) { if (eval < 0 || eval > 31) { @@ -754,28 +699,28 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); } } locp++; - *locp = (char)(*locp | (eval & 0x1F)); + *locp = (uint8_t)(*locp | (eval & 0x1F)); break; } if (!(eattr & DEFINED)) { + flags = MWORD; + if (w & FU_PCREL) - w = MPCREL | MWORD; - else - w = MWORD; + flags |= MPCREL; - rmark(sno, loc, 0, w, esym); + MarkRelocatable(sno, loc, 0, flags, esym); } else { if (tdb) - rmark(sno, loc, tdb, MWORD, NULL); + MarkRelocatable(sno, loc, tdb, MWORD, NULL); if (w & FU_SEXT) { if (eval + 0x10000 >= 0x20000) - goto range; + goto rangeErr; } else { @@ -783,101 +728,45 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); } if (w & FU_ISBRA) { if (eval + 0x8000 >= 0x10000) - goto range; + goto rangeErr; } else if (eval >= 0x10000) - goto range; + goto rangeErr; } } - *locp++ = (char)(eval >> 8); - *locp = (char)eval; + // 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: - if ((w & 0x0F00) == FU_MOVEI) - { -#if 0 - address = loc + 4; + flags = MLONG; - if (eattr & DEFINED) - { - for(j=0; j 0) - ship_ln(buf); - - if (err_flag) - write(err_fd, buf, (LONG)strlen(buf)); - else - printf("%s\n", buf); - } - } - else - { - if (!(eval & 0x0000000F) || ((eval - 2) % 4)) - { - err_setup(); - sprintf(buf, "* \'jump\' at $%08X - destination address not aligned for short page jump, insert a \'nop\' before the destination address", address); - - if (listing > 0) - ship_ln(buf); - - if (err_flag) - write(err_fd, buf, (LONG)strlen(buf)); - else - printf("%s\n", buf); - } - } - - // Clear this jump as it has been checked - fwdjump[j] = 0; - j = fwindex; - } - } - } -#endif - - eval = ((eval >> 16) & 0x0000FFFF) | ((eval << 16) & 0xFFFF0000); - flags = (MLONG | MMOVEI); + if ((w & FUMASKRISC) == FU_MOVEI) + { + // Long constant in MOVEI # is word-swapped, so fix it here + eval = WORDSWAP32(eval); + flags |= MMOVEI; } - else - flags = MLONG; + // If the symbol is undefined, make sure to pass the symbol in + // to the MarkRelocatable() function. if (!(eattr & DEFINED)) - { -//printf("Fixup (long): Symbol undefined. loc = $%X, long = $%X, flags = $%x\n", loc, eval, flags); - rmark(sno, loc, 0, flags, esym); - } + MarkRelocatable(sno, loc, 0, flags, esym); else if (tdb) - { -//printf("Fixup (long): TDB = $%X. loc =$%X, long = $%X, flags = $%x\n", tdb, loc, eval, flags); - rmark(sno, loc, tdb, flags, NULL); - } -//else -//printf("Fixup (long): TDB = $%X. loc =$%X, long = $%X, flags = $%x\n", tdb, loc, eval, flags); + MarkRelocatable(sno, loc, tdb, flags, NULL); - *locp++ = (char)(eval >> 24); - *locp++ = (char)(eval >> 16); - *locp++ = (char)(eval >> 8); - *locp = (char)eval; + SETBE32(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. + // (range of 1..8) in a word. Really bits 1..3 in a byte. case FU_QUICK: if (!(eattr & DEFINED)) { @@ -886,7 +775,7 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); } } if (eval < 1 || eval > 8) - goto range; + goto rangeErr; *locp |= (eval & 7) << 1; break; @@ -896,17 +785,18 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); } eval -= (loc + 1); if (eval + 0x80 >= 0x100) - goto range; + goto rangeErr; - *locp = (char)eval; + *locp = (uint8_t)eval; break; default: - interror(4); // Bad fixup type + // Bad fixup type--this should *never* happen! + interror(4); // NOTREACHED } continue; -range: +rangeErr: error("expression out of range"); } @@ -917,3 +807,22 @@ range: return 0; } +// +// Resolve all fixups +// +int ResolveAllFixups(void) +{ + // Make undefined symbols GLOBL + if (glob_flag) + ForceUndefinedSymbolsGlobal(); + + DEBUG printf("Resolving TEXT sections...\n"); + ResolveFixups(TEXT); + DEBUG printf("Resolving DATA sections...\n"); + ResolveFixups(DATA); + DEBUG printf("Resolving 6502 sections...\n"); + ResolveFixups(M6502); /* fixup 6502 section (if any) */ + + return 0; +} +