X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?p=rmac;a=blobdiff_plain;f=sect.c;h=fe630b15d3a2f8aaf1b4f8a36ac0d33f34b65f78;hp=89df4b4f38d2497ca6fcc5db5b03d8cc482ef02a;hb=75969398d9b8a9f82ea76fc4e4cbfb97b11160a4;hpb=49cce96fba11282e4244187f15be418d5ae5bb8d diff --git a/sect.c b/sect.c index 89df4b4..fe630b1 100644 --- a/sect.c +++ b/sect.c @@ -7,72 +7,95 @@ // #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 mksect(int, WORD); +void switchsect(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 +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 - -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. 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 }; +// +// Initialize Sections; Setup initial ABS, TEXT, DATA and BSS sections +// +void InitSection(void) +{ + int i; + + // Cleanup all sections + for(i=0; iscattr = attr; p->sloc = 0; p->scode = p->sfcode = NULL; @@ -86,19 +109,18 @@ void mksect(int sno, WORD attr) // void switchsect(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; @@ -106,8 +128,9 @@ void switchsect(int sno) 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; @@ -124,39 +147,17 @@ void savsect(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; ichnext) { fup.cp = (char *)ch->chptr; @@ -210,23 +212,24 @@ int fixtest(int sno, LONG loc) // 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 *)malloc(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) @@ -254,6 +257,9 @@ 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 +#define FIXUP_BASE_SIZE (sizeof(WORD) + sizeof(LONG) + sizeof(WORD) + sizeof(WORD)) // // Arrange for a fixup on a location // @@ -263,19 +269,27 @@ int fixup(WORD attr, LONG loc, TOKEN * fexpr) LONG len = 0; CHUNK * cp; SECT * p; + // 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 // 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 & 0x0F00) == 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 @@ -289,23 +303,25 @@ int fixup(WORD attr, LONG loc, TOKEN * fexpr) } len++; // Add 1 for ENDEXPR - i = (len << 2) + 12; +// 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; @@ -319,14 +335,15 @@ int fixup(WORD attr, LONG loc, TOKEN * fexpr) 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; @@ -336,10 +353,12 @@ int fixup(WORD attr, LONG loc, TOKEN * fexpr) } 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 & 0x0F00) == FU_JR) { if (orgactive) *fchptr.lp++ = orgaddr; @@ -355,7 +374,7 @@ int fixup(WORD attr, LONG loc, TOKEN * fexpr) // // Resolve all Fixups // -int fixups(void) +int ResolveAllFixups(void) { unsigned i; char buf[EBUFSIZ]; @@ -364,10 +383,15 @@ int fixups(void) if (glob_flag) syg_fix(); - resfix(TEXT); - resfix(DATA); - - // We need to do a final check of forward 'jump' destination addresses that are external + 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; isffix; + SECT * sc = §[sno]; + CHUNK * ch = sc->sffix; if (ch == NULL) return 0; - cch = sc->sfcode; // "cache" first chunk + CHUNK * cch = sc->sfcode; // "cache" first chunk - if (cch == NULL) // Can't fixup a sect with nothing in it + if (cch == NULL) // Can't fixup a sect with nothing in it 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) { @@ -438,12 +460,17 @@ int resfix(int sno) 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) @@ -454,18 +481,18 @@ int resfix(int sno) if (cch == NULL) { - interror(7); // Fixup (loc) out of range + interror(7); // Fixup (loc) out of range // 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) @@ -476,8 +503,9 @@ int resfix(int sno) fup.lp += i; } + // Simple symbol else - { // Simple symbol + { sy = *fup.sy++; eattr = sy->sattr; @@ -486,7 +514,7 @@ int resfix(int sno) else eval = 0; - if ((eattr & (GLOBAL|DEFINED)) == GLOBAL) + if ((eattr & (GLOBAL | DEFINED)) == GLOBAL) esym = sy; } @@ -505,14 +533,17 @@ int resfix(int sno) // 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) @@ -561,7 +592,7 @@ int resfix(int sno) break; // Fixup one-byte value at locp + 1. case FU_WBYTE: - ++locp; + locp++; // FALLTHROUGH // Fixup one-byte forward references case FU_BYTE: @@ -591,24 +622,23 @@ int resfix(int sno) *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 & 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 forward declared labels + // Main code destination alignment checking here for + // forward declared labels address = (oaddr) ? oaddr : loc; if (((address >= 0xF03000) && (address < 0xF04000) @@ -624,7 +654,8 @@ int resfix(int sno) 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); @@ -640,6 +671,7 @@ int resfix(int sno) } } } +#endif if ((reg2 < -16) || (reg2 > 15)) { @@ -762,10 +794,12 @@ int resfix(int sno) *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 0 address = loc + 4; if (eattr & DEFINED) @@ -815,27 +849,33 @@ int resfix(int sno) } } } +#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: @@ -850,6 +890,7 @@ int resfix(int sno) *locp |= (eval & 7) << 1; break; + // Fix up 6502 funny branch case FU_6BRA: eval -= (loc + 1); @@ -859,6 +900,7 @@ int resfix(int sno) *locp = (char)eval; break; + default: interror(4); // Bad fixup type // NOTREACHED @@ -874,3 +916,4 @@ range: return 0; } +