PTR markptr; // Deposit point in current mark chunk
LONG mcalloc; // #bytes alloc'd to current mark chunk
LONG mcused; // #bytes used in current mark chunk
-WORD curfrom; // Current "from" section
+uint16_t curfrom; // Current "from" section
+
+
+//#define DEBUG_IMAGE_MARKING
//
{
if (curmch)
{
- *markptr.wp = MCHEND; // Mark end of block
- curmch->mcused = mcused; // Update #used in mark block
+ *markptr.wp = MCHEND; // Mark end of block
+ curmch->mcused = mcused; // Update #used in mark block
}
}
//
// Mark a word or longword relocatable
//
-int rmark(int from, LONG loc, int to, int size, SYM * symbol)
+int rmark(uint16_t from, uint32_t loc, uint16_t to, uint16_t size, SYM * symbol)
{
- WORD w;
+#ifdef DEBUG_IMAGE_MARKING
+printf("rmark: from=%i, loc=$%X, to=$%X, size=$%x, symbol=$%X\n", from, loc, to, size, symbol);
+#endif
+// uint16_t w;
if ((mcalloc - mcused) < MIN_MARK_MEM)
amark();
- w = (WORD)(size | to);
+ uint16_t flags = (size | to);
if (from != curfrom)
- w |= MCHFROM;
+ flags |= MCHFROM;
if (symbol != NULL)
- w |= MSYMBOL;
+ flags |= MSYMBOL;
mcused += sizeof(WORD) + sizeof(LONG);
- *markptr.wp++ = w;
+ *markptr.wp++ = flags;
*markptr.lp++ = loc;
- if (w & MCHFROM)
+ if (flags & MCHFROM)
{
- *markptr.wp++ = (WORD)from;
- curfrom = (WORD)from;
+ curfrom = from;
+ *markptr.wp++ = from;
mcused += sizeof(WORD);
}
- if (w & MSYMBOL)
+ if (flags & MSYMBOL)
{
*markptr.sy++ = symbol;
- mcused += sizeof(LONG);
+ mcused += sizeof(SYM *);
}
*markptr.wp = 0x0000;
//
int amark(void)
{
- MCHUNK * p;
+// MCHUNK * p;
// Alloc mark block header (and data) and set it up.
// p = (MCHUNK *)amem((long)(sizeof(MCHUNK)) + MARK_ALLOC_INCR);
- p = (MCHUNK *)malloc(sizeof(MCHUNK) + MARK_ALLOC_INCR);
+ MCHUNK * p = (MCHUNK *)malloc(sizeof(MCHUNK) + MARK_ALLOC_INCR);
p->mcnext = NULL;
p->mcalloc = MARK_ALLOC_INCR;
p->mcptr.cp = (char *)(((char *)p) + sizeof(MCHUNK));
if (curmch)
- { // Link onto previous chunk
- *markptr.wp++ = MCHEND; // Mark end of block
+ {
+ // Link onto previous chunk
+ *markptr.wp++ = MCHEND; // Mark end of block
curmch->mcused = mcused;
curmch->mcnext = p;
}
if (!firstmch)
firstmch = p;
- curmch = p; // Setup global vars
+ curmch = p; // Setup global vars
markptr = p->mcptr;
mcalloc = MARK_ALLOC_INCR;
mcused = 0;
//
// Make mark image for BSD .o file
//
-LONG bsdmarkimg(char * mp, LONG siz, LONG tsize, int reqseg)
+uint32_t bsdmarkimg(char * mp, LONG siz, LONG tsize, int reqseg)
{
- MCHUNK * mch; // Mark chunk
- PTR p; // Source point from within mark chunk
- WORD from; // Section fixups are currently FROM
- WORD w; // A word (temp)
- LONG loc; // Location (temp)
- SYM * symbol; // Symbols (temp)
- char * wp; // Pointer into raw relocation info
- char * dp; // Deposit point for RELMOD info
- LONG diff; // Difference to relocate (RELMOD)
- LONG raddr, rflag = 0; // BSD relocation address and flags
- LONG rsize; // Relocation size
- int validsegment = 0; // Valid segment being processed
-
- rsize = 0; // Initialise relocation size
+ MCHUNK * mch; // Mark chunk
+ PTR p; // Source point from within mark chunk
+ uint16_t from; // Section fixups are currently FROM
+ uint16_t w; // A word (temp)
+ uint32_t loc; // Location (temp)
+ SYM * symbol; // Symbols (temp)
+ uint8_t * wp; // Pointer into raw relocation info
+ uint8_t * dp; // Deposit point for RELMOD info
+ uint32_t diff; // Difference to relocate (RELMOD)
+ uint32_t raddr, rflag = 0; // BSD relocation address and flags
+ uint32_t rsize; // Relocation size
+ int validsegment = 0; // Valid segment being processed
+
+#ifdef DEBUG_IMAGE_MARKING
+printf("bsdmarkimg():\n");
+#endif
+ // Initialise relocation size
+ rsize = 0;
chptr = mp;
-
from = 0;
- for(mch = firstmch; mch != NULL; mch = mch->mcnext)
+
+ for(mch=firstmch; mch!=NULL; mch=mch->mcnext)
{
for(p=mch->mcptr;;)
{
- w = *p.wp++; // Next mark entry
+ w = *p.wp++; // Next mark entry
if (w & MCHEND)
- break; // End of mark chunk
+ break; // End of mark chunk
// Get mark record
symbol = NULL;
- loc = *p.lp++; // Mark location
+ loc = *p.lp++; // Mark location
if (w & MCHFROM)
- { // Maybe change "from" section
+ {
+ // Maybe change "from" section
from = *p.wp++;
if (obj_format == BSD)
{
if (reqseg == TEXT)
- { // Requested segment is TEXT
+ {
+ // Requested segment is TEXT
if (from == TEXT)
validsegment = 1;
else
validsegment = 0;
}
else
- { // Requested segment is DATA
+ {
+ // Requested segment is DATA
if (from == DATA)
validsegment = 1;
else
}
}
- if (w & MSYMBOL) // Maybe includes a symbol
+ if (w & MSYMBOL) // Maybe includes a symbol
symbol = *p.sy++;
if (obj_format == BSD)
{
- raddr = loc; // Set relocation address
+ raddr = loc; // Set relocation address
if (validsegment)
- D_long(raddr); // Write relocation address
+#ifdef DEBUG_IMAGE_MARKING
+{
+printf(" validsegment: raddr = $%08X\n", raddr);
+#endif
+ D_long(raddr); // Write relocation address
+#ifdef DEBUG_IMAGE_MARKING
+}
+#endif
if (w & MPCREL)
- rflag = 0x000000A0; // PC-relative fixup
+ rflag = 0x000000A0; // PC-relative fixup
else
- rflag = 0x00000040; // Absolute fixup
+ rflag = 0x00000040; // Absolute fixup
if (w & MMOVEI)
rflag |= 0x00000001;
if (from == DATA)
loc += tsize;
- wp = (char *)(mp + loc);
+ wp = (uint8_t *)(mp + loc);
if (symbol)
{
// Deposit external reference
if (obj_format == BSD)
{
- rflag |= 0x00000010; // Set external reloc flag bit
- rflag |= (symbol->senv << 8); // Put symbol index in flags
+ rflag |= 0x00000010; // Set external reloc flag bit
+ rflag |= (symbol->senv << 8); // Put symbol index in flags
if (symbol->sattre & RISCSYM)
rflag |= 0x00000001;
if (validsegment)
{
- D_long(rflag); // Write relocation flags
- rsize += 8; // Increment relocation size
+#ifdef DEBUG_IMAGE_MARKING
+printf(" validsegment(2): rflag = $%08X\n", rflag);
+#endif
+ D_long(rflag); // Write relocation flags
+ rsize += 8; // Increment relocation size
}
}
}
{
if (obj_format == BSD)
{
- w &= TDB; // Set reloc flags to segment
+#ifdef DEBUG_IMAGE_MARKING
+printf(" w = $%04X\n", w);
+#endif
+ w &= TDB; // Set reloc flags to segment
switch (w)
{
if (validsegment)
{
- D_long(rflag); // Write relocation flags
- rsize += 8; // Increment relocation size
+#ifdef DEBUG_IMAGE_MARKING
+printf(" validsegment(3): rflag = $%08X\n", rflag);
+#endif
+ D_long(rflag); // Write relocation flags
+ rsize += 8; // Increment relocation size
}
w &= TDB;
diff |= ((LONG)(*dp++ & 0xFF)) << 8;
diff |= (LONG)(*dp & 0xFF);
DEBUG printf("diff=%ux ==> ", diff);
+#ifdef DEBUG_IMAGE_MARKING
+printf(" validsegment(4): diff = $%08X --> ", diff);
+#endif
if (rflag & 0x01)
diff = ((diff >> 16) & 0x0000FFFF) | ((diff << 16) & 0xFFFF0000);
*dp++ = (char)(diff >> 8);
*dp = (char)diff;
DEBUG printf("%ux\n", diff);
+#ifdef DEBUG_IMAGE_MARKING
+printf("$%08X\n", diff);
+#endif
}
}
}
// Return relocation size
if (obj_format == BSD)
+#ifdef DEBUG_IMAGE_MARKING
+{
+printf(" rsize = $%X\n", rsize);
+#endif
return rsize;
+#ifdef DEBUG_IMAGE_MARKING
+}
+#endif
return siz;
}
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.
CHUNK * cp;
SECT * p;
// Shamus: Expression lengths are voodoo ATM (varibale "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;
}
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;
}
+
projects / rmac / commitdiff