//
#include "sect.h"
+#include "direct.h"
#include "error.h"
+#include "expr.h"
+#include "listing.h"
#include "mach.h"
-#include "token.h"
#include "mark.h"
-#include "expr.h"
+#include "riscasm.h"
#include "symbol.h"
-#include "risca.h"
-#include "listing.h"
+#include "token.h"
+
+
+// Function prototypes
+void MakeSection(int, WORD);
+void SwitchSection(int);
// Section descriptors
-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
-
-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 * 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
-
-unsigned fwdjump[MAXFWDJUMPS]; // forward jump check table
-unsigned fwindex = 0; // forward jump index
-
-// Return a size (SIZB, SIZW, SIZL) or 0, depending on what kind of fixup is associated
-// with a location.
+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
+
+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 * 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
+
+// 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
+ 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
+ 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 mksect(int sno, WORD attr)
+void InitSection(void)
{
- SECT * p; // Section pointer
+ int i;
+
+ // Cleanup all sections
+ for(i=0; i<NSECTS; i++)
+ MakeSection(i, 0);
+
+ // Construct default sections, make TEXT the current section
+ MakeSection(ABS, SUSED | SABS | SBSS); // ABS
+ MakeSection(TEXT, SUSED | TEXT ); // TEXT
+ MakeSection(DATA, SUSED | DATA ); // DATA
+ MakeSection(BSS, SUSED | BSS | SBSS); // BSS
+// MakeSection(M6502, SUSED | TEXT ); // 6502 code section
+
+ SwitchSection(TEXT); // Switch to TEXT for starters
+}
+
- p = §[sno];
+//
+// Make a New (Clean) Section
+//
+void MakeSection(int sno, WORD attr)
+{
+ SECT * p = §[sno];
p->scattr = attr;
p->sloc = 0;
p->scode = p->sfcode = NULL;
//
-// 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)
{
- SECT * p; // Section pointer
- CHUNK * cp; // Chunk pointer
-
+ CHUNK * cp; // Chunk pointer
cursect = sno;
- p = §[sno];
+ SECT * p = §[sno];
- scattr = p->scattr; // Copy section vars
+ scattr = p->scattr; // Copy section vars
sloc = p->sloc;
scode = p->scode;
sfix = p->sfix;
+ // Copy code chunk vars
if ((cp = scode) != NULL)
- { // Copy code chunk vars
+ {
challoc = cp->challoc;
ch_size = cp->ch_size;
chptr = cp->chptr + ch_size;
else
challoc = ch_size = 0;
+ // Copy fixup chunk vars
if ((cp = sfix) != NULL)
- { // Copy fixup chunk vars
+ {
fchalloc = cp->challoc;
fchsize = cp->ch_size;
fchptr.cp = cp->chptr + fchsize;
//
-// Save Current Section
+// Save current section
//
-void savsect(void)
+void SaveSection(void)
{
SECT * p = §[cursect];
- p->scattr = scattr; // Bailout section vars
+ p->scattr = scattr; // Bailout section vars
p->sloc = sloc;
- if (scode != NULL) // Bailout code chunk
+ if (scode != NULL) // Bailout code chunk
scode->ch_size = ch_size;
- if (sfix != NULL) // Bailout fixup chunk
+ if (sfix != NULL) // Bailout fixup chunk
sfix->ch_size = fchsize;
}
-//
-// Initialize Sections; Setup initial ABS, TEXT, DATA and BSS sections
-//
-void init_sect(void)
-{
- int i; // Iterator
-
- // Cleanup all sections
- for(i=0; i<NSECTS; ++i)
- mksect(i, 0);
-
- // Construct default sections, make TEXT the current section
- mksect(ABS, SUSED|SABS|SBSS); // ABS
- mksect(TEXT, SUSED|TEXT ); // TEXT
- mksect(DATA, SUSED|DATA ); // DATA
- mksect(BSS, SUSED|BSS |SBSS); // BSS
-// mksect(M6502, SUSED|TEXT ); // 6502 code section
-
- switchsect(TEXT); // Switch to TEXT for starters
-}
-
-
//
// Test to see if a location has a fixup sic'd on it. This is used by the
// listing generator to print 'xx's instead of '00's for forward references
WORD w;
LONG xloc;
- stopmark(); // Force update to sect[] variables
+ stopmark(); // Force update to sect[] variables
// 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.
+ // the speed doesn't matter, since this is only done when generating a
+ // listing, which is SLOW.
for(ch=sect[sno].sffix; ch!=NULL; ch=ch->chnext)
{
fup.cp = (char *)ch->chptr;
//
int chcheck(LONG amt)
{
- CHUNK * cp;
- SECT * p;
-
+ DEBUG { printf("chcheck(%u)\n", amt); }
+ // If in BSS section, no allocation required
if (scattr & SBSS)
- return 0; // If in BSS section, forget it
+ return 0;
if (!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)
return 0;
if (amt < CH_CODE_SIZE)
amt = CH_CODE_SIZE;
- p = §[cursect];
- cp = (CHUNK *)amem((long)(sizeof(CHUNK) + amt));
+ DEBUG { printf(" amt (adjusted)=%u\n", amt); }
+ SECT * p = §[cursect];
+ CHUNK * cp = malloc(sizeof(CHUNK) + amt);
+ // First chunk in section
if (scode == NULL)
- { // First chunk in section
+ {
cp->chprev = NULL;
p->sfcode = cp;
}
+ // Add chunk to other chunks
else
- { // Add chunk to other chunks
+ {
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
}
+// 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))
//
// Arrange for a fixup on a location
//
-int fixup(WORD attr, LONG loc, TOKEN * fexpr)
+int AddFixup(WORD attr, LONG loc, TOKEN * fexpr)
{
LONG i;
LONG len = 0;
CHUNK * cp;
SECT * p;
+ // Shamus: Expression lengths are voodoo ATM (variable "i"). Need to fix this.
+#warning "!!! AddFixup() is filled with VOODOO !!!"
+ 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
+ // 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)
{
- if ((attr & 0x0F00) == FU_JR) // SCPCD : correct bit mask for attr (else other FU_xxx will match) NYAN !
+ // Just a single symbol
+ // SCPCD : correct bit mask for attr (else other FU_xxx will match) NYAN !
+ if ((attr & FUMASKRISC) == FU_JR)
{
- i = 18; // Just a single symbol
+// i = 18;
+// i = FIXUP_BASE_SIZE + (sizeof(LONG) * 2);
+ i = FIXUP_BASE_SIZE + sizeof(SYM *) + sizeof(LONG);
}
else
{
- i = 14;
+// i = 14;
+ i = FIXUP_BASE_SIZE + sizeof(SYM *);
}
}
else
{
attr |= FU_EXPR;
- for(len=0; fexpr[len]!=ENDEXPR; ++len)
+ for(len=0; fexpr[len]!=ENDEXPR; len++)
{
if (fexpr[len] == CONST || fexpr[len] == SYMBOL)
- ++len;
+ len++;
}
- ++len; // Add 1 for ENDEXPR
- i = (len << 2) + 12;
+ len++; // Add 1 for ENDEXPR
+// i = (len << 2) + 12;
+ i = FIXUP_BASE_SIZE + sizeof(WORD) + (len * sizeof(TOKEN));
}
// Maybe alloc another fixup chunk for this one to fit in
if ((fchalloc - fchsize) < i)
{
p = §[cursect];
- cp = (CHUNK *)amem((long)(sizeof(CHUNK) + CH_FIXUP_SIZE));
+ cp = (CHUNK *)malloc(sizeof(CHUNK) + CH_FIXUP_SIZE);
+ // First fixup chunk in section
if (sfix == NULL)
- { // First fixup chunk in section
+ {
cp->chprev = NULL;
p->sffix = cp;
}
+ // Add to other chunks
else
- { // Add to other chunks
+ {
cp->chprev = sfix;
sfix->chnext = cp;
sfix->ch_size = fchsize;
sfix = p->sfix = cp;
}
- // Record fixup type, fixup location, and the file number and line number the fixup is
- // located at.
+ // Record fixup type, fixup location, and the file number and line number
+ // the fixup is located at.
*fchptr.wp++ = attr;
*fchptr.lp++ = loc;
*fchptr.wp++ = cfileno;
*fchptr.wp++ = (WORD)curlineno;
- // Store postfix expression or pointer to a single symbol, or nothing for a mark.
+ // Store postfix expression or pointer to a single symbol, or nothing for a
+ // mark.
if (attr & FU_EXPR)
{
*fchptr.wp++ = (WORD)len;
}
else
{
- *fchptr.lp++ = (LONG)fexpr[1];
+// *fchptr.lp++ = (LONG)fexpr[1];
+ *fchptr.sy++ = symbolPtr[fexpr[1]];
}
- if ((attr & 0x0F00) == FU_JR) // SCPCD : correct bit mask for attr (else other FU_xxx will match) NYAN !
+ // SCPCD : correct bit mask for attr (else other FU_xxx will match) NYAN !
+ if ((attr & FUMASKRISC) == FU_JR)
{
if (orgactive)
*fchptr.lp++ = orgaddr;
}
fchsize += i;
-
return 0;
}
//
// Resolve all Fixups
//
-int fixups(void)
+int ResolveAllFixups(void)
{
unsigned i;
char buf[EBUFSIZ];
if (glob_flag)
syg_fix();
- resfix(TEXT);
- resfix(DATA);
-
- // We need to do a final check of forward 'jump' destination addresses that are external
- for(i=0; i<MAXFWDJUMPS; i++)
- {
- if (fwdjump[i])
- {
- err_setup();
- sprintf(buf, "* \'jump\' at $%08X - destination address is external to this source file and cannot have its aligment validated", fwdjump[i]);
-
- if (listing > 0)
- ship_ln(buf);
-
- if (err_flag)
- write(err_fd, buf, (LONG)strlen(buf));
- else
- printf("%s\n", buf);
- }
- }
+ DEBUG printf("Resolving TEXT sections...\n");
+ ResolveFixups(TEXT);
+ DEBUG printf("Resolving DATA sections...\n");
+ ResolveFixups(DATA);
return 0;
}
//
// Resolve Fixups in a Section
//
-int resfix(int sno)
+int ResolveFixups(int sno)
{
- SECT * sc; // Section
- CHUNK * ch;
PTR fup; // Current fixup
WORD * fuend; // End of last fixup (in this chunk)
- CHUNK * cch; // Cached chunk for target
WORD w; // Fixup word (type+modes+flags)
char * locp; // Location to fix (in cached chunk)
LONG loc; // Location to fixup
unsigned j;
char buf[EBUFSIZ];
- sc = §[sno];
- ch = sc->sffix;
+ SECT * sc = §[sno];
+ CHUNK * ch = sc->sffix;
if (ch == NULL)
return 0;
- 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 sect with nothing in it
+ if (cch == NULL)
return 0;
do
{
- fup.cp = ch->chptr; // fup -> start of chunk
- fuend = (WORD *)(fup.cp + ch->ch_size); // fuend -> end of chunk
+ fup.cp = ch->chptr; // fup -> start of chunk
+ fuend = (WORD *)(fup.cp + ch->ch_size); // fuend -> end of chunk
while (fup.wp < fuend)
{
loc = *fup.lp++;
cfileno = *fup.wp++;
curlineno = (int)*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.
+ SetFilenameForErrorReporting();
esym = NULL;
- // 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.
+ // 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 (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;
// Compute expression/symbol value and attribs
+ // Complex expression
if (w & FU_EXPR)
- { // Complex expression
+ {
i = *fup.wp++;
if (evexpr(fup.tk, &eval, &eattr, &esym) != OK)
fup.lp += i;
}
+ // Simple symbol
else
- { // Simple symbol
+ {
sy = *fup.sy++;
eattr = sy->sattr;
else
eval = 0;
- if ((eattr & (GLOBAL|DEFINED)) == GLOBAL)
+ if ((eattr & (GLOBAL | DEFINED)) == GLOBAL)
esym = sy;
}
// If the expression is undefined and no external symbol is
// involved, then it's an error.
- if (!(eattr & DEFINED) && esym == NULL)
+ if (!(eattr & DEFINED) && (esym == NULL))
{
error(undef_error);
continue;
}
- if (((w & 0x0F00) == FU_MOVEI) && esym)
+// It seems that this is completely unnecessary!
+#if 0
+ if (((w & FUMASKRISC) == FU_MOVEI) && esym)
+//{
+//printf("DoFixups: Setting symbol attre to RISCSYM...\n");
esym->sattre |= RISCSYM;
+//}
+#endif
// 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).
+ // 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).
+ // 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).
+ // PC-relative fixups must be DEFINED and either in the same
+ // section (whereupon the subtraction takes place) or ABS (with no
+ // subtract).
if (w & FU_PCREL)
{
if (eattr & DEFINED)
break;
// Fixup one-byte value at locp + 1.
case FU_WBYTE:
- ++locp;
+ locp++;
// FALLTHROUGH
// Fixup one-byte forward references
case FU_BYTE:
*locp = (char)eval;
break;
// Fixup WORD forward references;
- // the word could be unaligned in the section buffer, so we have to be careful.
+ // 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)// || ((w & 0x0F00) == FU_MJR))
{
oaddr = *fup.lp++;
if (oaddr)
- {
reg2 = (signed)((eval - (oaddr + 2)) / 2);// & 0x1F;
- }
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
+ // Main code destination alignment checking here for
+ // forward declared labels
address = (oaddr) ? oaddr : loc;
if (((address >= 0xF03000) && (address < 0xF04000)
if (page_jump)
{
- // This jump is to a page outside of the current 256 byte page
+ // 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);
}
}
}
+#endif
if ((reg2 < -16) || (reg2 > 15))
{
break;
}
- if ((w & 0x0F00) == FU_NUM15)
+ if ((w & FUMASKRISC) == FU_NUM15)
{
if (eval < -16 || eval > 15)
{
break;
}
- if ((w & 0x0F00) == FU_NUM31)
+ if ((w & FUMASKRISC) == FU_NUM31)
{
if (eval < 0 || eval > 31)
{
break;
}
- if ((w & 0x0F00) == FU_NUM32)
+ if ((w & FUMASKRISC) == FU_NUM32)
{
if (eval < 1 || eval > 32)
{
break;
}
- if ((w & 0x0F00) == FU_REGONE)
+ if ((w & FUMASKRISC) == FU_REGONE)
{
if (eval < 0 || eval > 31)
{
break;
}
- if ((w & 0x0F00) == FU_REGTWO)
+ if ((w & FUMASKRISC) == FU_REGTWO)
{
if (eval < 0 || eval > 31)
{
*locp = (char)eval;
break;
// Fixup LONG forward references;
- // the long could be unaligned in the section buffer, so be careful (again).
+ // the long could be unaligned in the section buffer, so be careful
+ // (again).
case FU_LONG:
- if ((w & 0x0F00) == FU_MOVEI)
+ if ((w & FUMASKRISC) == FU_MOVEI)
{
+#if 0
address = loc + 4;
if (eattr & DEFINED)
}
}
}
+#endif
+ // Long constant in MOVEI # is word-swapped, so fix it here
eval = ((eval >> 16) & 0x0000FFFF) | ((eval << 16) & 0xFFFF0000);
- flags = (MLONG|MMOVEI);
+ flags = (MLONG | MMOVEI);
}
else
flags = MLONG;
if (!(eattr & DEFINED))
{
+//printf("Fixup (long): Symbol undefined. loc = $%X, long = $%X, flags = $%x\n", loc, eval, flags);
rmark(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);
*locp++ = (char)(eval >> 24);
*locp++ = (char)(eval >> 16);
*locp++ = (char)(eval >> 8);
*locp = (char)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:
*locp |= (eval & 7) << 1;
break;
+
// Fix up 6502 funny branch
case FU_6BRA:
eval -= (loc + 1);
*locp = (char)eval;
break;
+
default:
interror(4); // Bad fixup type
// NOTREACHED
return 0;
}
+
projects / rmac / blobdiff