#include "listing.h"
#include "mach.h"
#include "mark.h"
-#include "risca.h"
+#include "riscasm.h"
#include "symbol.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
+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
+WORD scattr; // Section attributes
+LONG sloc; // Current loc in section
-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
+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
-// BOLLOCKS
-//unsigned fwdjump[MAXFWDJUMPS]; // forward jump check table
-//unsigned fwindex = 0; // forward jump index
+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.
//
-// Make a New (Clean) Section
+// Initialize sections; setup initial ABS, TEXT, DATA and BSS sections
+//
+void InitSection(void)
+{
+ 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
+
+ // Switch to TEXT for starters
+ SwitchSection(TEXT);
+}
+
+
+//
+// Make a new (clean) section
//
-void mksect(int sno, WORD attr)
+void MakeSection(int sno, WORD attr)
{
SECT * p = §[sno];
p->scattr = 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
+ // Copy section vars
+ scattr = p->scattr;
sloc = p->sloc;
scode = p->scode;
sfix = p->sfix;
//
-// Save Current Section
+// Save current section
//
-void savsect(void)
+void SaveSection(void)
{
SECT * p = §[cursect];
}
-//
-// Initialize Sections; Setup initial ABS, TEXT, DATA and BSS sections
-//
-void init_sect(void)
-{
- int i;
-
- // 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
+ // Force update to sect[] variables
+ StopMark();
- // 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.
+ // 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(ch=sect[sno].sffix; ch!=NULL; ch=ch->chnext)
{
fup.cp = (char *)ch->chptr;
fup.lp += w;
}
else
- ++fup.lp;
+ fup.lp++;
}
}
//
-// 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.
+// If 'amt' is zero, ensure there are at least CH_THRESHOLD bytes, likewise.
//
int chcheck(LONG amt)
{
}
-// 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
+// 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 (varibale "i"). Need to fix this.
-#warning "!!! fixup() is filled with VOODOO !!!"
+ // 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
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)
+ // SCPCD : correct bit mask for attr (else other FU_xxx will match)
+ // NYAN !
+ if ((attr & FUMASKRISC) == FU_JR)
{
+//printf("AddFixup: ((attr & FUMASKRISC) == FU_JR)\n");
// i = 18;
// i = FIXUP_BASE_SIZE + (sizeof(LONG) * 2);
i = FIXUP_BASE_SIZE + sizeof(SYM *) + sizeof(LONG);
}
else
{
+//printf("AddFixup: ((attr & FUMASKRISC) == FU_JR) ELSE\n");
// i = 14;
i = FIXUP_BASE_SIZE + sizeof(SYM *);
}
}
else
{
+//printf("AddFixup: !SYMBOL\n");
attr |= FU_EXPR;
for(len=0; fexpr[len]!=ENDEXPR; len++)
i = FIXUP_BASE_SIZE + sizeof(WORD) + (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];
{
// *fchptr.lp++ = (LONG)fexpr[1];
*fchptr.sy++ = symbolPtr[fexpr[1]];
+//printf("AddFixup: adding symbol (%s) [%08X]\n", symbolPtr[fexpr[1]]->sname, symbolPtr[fexpr[1]]->sattr);
}
// SCPCD : correct bit mask for attr (else other FU_xxx will match) NYAN !
- if ((attr & 0x0F00) == FU_JR)
+ if ((attr & FUMASKRISC) == FU_JR)
{
if (orgactive)
*fchptr.lp++ = orgaddr;
//
-// Resolve all Fixups
+// Resolve all fixups
//
int ResolveAllFixups(void)
{
// Make undefined symbols GLOBL
if (glob_flag)
- syg_fix();
+ ForceUndefinedSymbolsGlobal();
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<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);
- }
- }
-#endif
-
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
+ 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;
int reg2;
WORD flags;
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;
do
if (cch == NULL)
{
- interror(7); // Fixup (loc) out of range
+ // Fixup (loc) out of range
+ interror(7);
// NOTREACHED
}
}
// 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
//
// 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++;
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)
{
// 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;
}
#endif
+ // Long constant in MOVEI # is word-swapped, so fix it here
eval = ((eval >> 16) & 0x0000FFFF) | ((eval << 16) & 0xFFFF0000);
flags = (MLONG | MMOVEI);
}
break;
default:
- interror(4); // Bad fixup type
+ // Bad fixup type--this should *never* happen!
+ interror(4);
// NOTREACHED
}
continue;
projects / rmac / blobdiff