#include "listing.h"
#include "mach.h"
#include "mark.h"
-#include "risca.h"
+#include "riscasm.h"
#include "symbol.h"
#include "token.h"
+
// 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
+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 * 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
+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
+// BOLLOCKS
+//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.
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
};
LONG len = 0;
CHUNK * cp;
SECT * p;
- // Shamus: Expression lengths are voodoo ATM (varibale "i"). Need to fix this.
+ // Shamus: Expression lengths are voodoo ATM (variable "i"). Need to fix this.
+#warning "!!! fixup() is filled with VOODOO !!!"
DEBUG printf("FIXUP@$%X: $%X\n", loc, attr);
// Compute length of expression (could be faster); determine if it's the
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++)
printf("%s\n", buf);
}
}
+#endif
return 0;
}
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;
break;
// Fixup one-byte value at locp + 1.
case FU_WBYTE:
- ++locp;
+ locp++;
// FALLTHROUGH
// Fixup one-byte forward references
case FU_BYTE:
// 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 & 0x0F00) == 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
}
}
}
+#endif
if ((reg2 < -16) || (reg2 > 15))
{
case FU_LONG:
if ((w & 0x0F00) == FU_MOVEI)
{
+#if 0
address = loc + 4;
if (eattr & DEFINED)
}
}
}
+#endif
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;
}
+