X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?p=rmac;a=blobdiff_plain;f=sect.c;h=7331cb3d765c4e867ce727cb39bce3b9e0c711d1;hp=1046588fd31e073351f6d363beb75e74a4da5a20;hb=d0c28c349ddfb8393568037f68bddbe8979ce0df;hpb=daf2f61a3664329ae7f9609e1e14da2b8780fd10 diff --git a/sect.c b/sect.c index 1046588..7331cb3 100644 --- a/sect.c +++ b/sect.c @@ -3,7 +3,7 @@ // SECT.C - Code Generation, Fixups and Section Management // Copyright (C) 199x Landon Dyer, 2011 Reboot and Friends // RMAC derived from MADMAC v1.07 Written by Landon Dyer, 1986 -// Source Utilised with the Kind Permission of Landon Dyer +// Source utilised with the kind permission of Landon Dyer // #include "sect.h" @@ -13,63 +13,88 @@ #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 -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 }; // -// Make a New (Clean) Section +// Initialize sections; setup initial ABS, TEXT, DATA and BSS sections // -void mksect(int sno, WORD attr) +void InitSection(void) +{ + int i; + + // Cleanup all sections + for(i=0; iscattr = attr; @@ -80,16 +105,17 @@ void mksect(int sno, WORD 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; @@ -117,9 +143,9 @@ void switchsect(int sno) // -// Save Current Section +// Save current section // -void savsect(void) +void SaveSection(void) { SECT * p = §[cursect]; @@ -134,28 +160,6 @@ void savsect(void) } -// -// Initialize Sections; Setup initial ABS, TEXT, DATA and BSS sections -// -void init_sect(void) -{ - int i; - - // Cleanup all sections - for(i=0; ichnext) { fup.cp = (char *)ch->chptr; @@ -193,7 +198,7 @@ int fixtest(int sno, LONG loc) fup.lp += w; } else - ++fup.lp; + fup.lp++; } } @@ -202,14 +207,15 @@ int fixtest(int sno, LONG loc) // -// 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) { + DEBUG { printf("chcheck(%u)\n", amt); } // If in BSS section, no allocation required if (scattr & SBSS) return 0; @@ -217,12 +223,14 @@ int chcheck(LONG amt) 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; + DEBUG { printf(" amt (adjusted)=%u\n", amt); } SECT * p = §[cursect]; CHUNK * cp = malloc(sizeof(CHUNK) + amt); @@ -252,19 +260,21 @@ 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. + // 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 @@ -273,21 +283,25 @@ int fixup(WORD attr, LONG loc, TOKEN * fexpr) 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++) @@ -301,7 +315,7 @@ int fixup(WORD attr, LONG loc, TOKEN * fexpr) 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]; @@ -349,10 +363,11 @@ int fixup(WORD attr, LONG loc, TOKEN * fexpr) { // *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; @@ -366,7 +381,7 @@ int fixup(WORD attr, LONG loc, TOKEN * fexpr) // -// Resolve all Fixups +// Resolve all fixups // int ResolveAllFixups(void) { @@ -375,52 +390,33 @@ 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); - - // We need to do a final check of forward 'jump' destination addresses that - // are external - for(i=0; i 0) - ship_ln(buf); - - if (err_flag) - write(err_fd, buf, (LONG)strlen(buf)); - else - printf("%s\n", buf); - } - } 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; @@ -435,9 +431,11 @@ int ResolveFixups(int sno) 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 @@ -451,6 +449,10 @@ int ResolveFixups(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; @@ -468,7 +470,8 @@ int ResolveFixups(int sno) if (cch == NULL) { - interror(7); // Fixup (loc) out of range + // Fixup (loc) out of range + interror(7); // NOTREACHED } } @@ -509,14 +512,20 @@ int ResolveFixups(int sno) // 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 // @@ -579,7 +588,7 @@ int ResolveFixups(int sno) break; // Fixup one-byte value at locp + 1. case FU_WBYTE: - ++locp; + locp++; // FALLTHROUGH // Fixup one-byte forward references case FU_BYTE: @@ -612,19 +621,16 @@ int ResolveFixups(int sno) // 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 @@ -661,6 +667,7 @@ int ResolveFixups(int sno) } } } +#endif if ((reg2 < -16) || (reg2 > 15)) { @@ -674,7 +681,7 @@ int ResolveFixups(int sno) break; } - if ((w & 0x0F00) == FU_NUM15) + if ((w & FUMASKRISC) == FU_NUM15) { if (eval < -16 || eval > 15) { @@ -688,7 +695,7 @@ int ResolveFixups(int sno) break; } - if ((w & 0x0F00) == FU_NUM31) + if ((w & FUMASKRISC) == FU_NUM31) { if (eval < 0 || eval > 31) { @@ -702,7 +709,7 @@ int ResolveFixups(int sno) break; } - if ((w & 0x0F00) == FU_NUM32) + if ((w & FUMASKRISC) == FU_NUM32) { if (eval < 1 || eval > 32) { @@ -720,7 +727,7 @@ int ResolveFixups(int sno) break; } - if ((w & 0x0F00) == FU_REGONE) + if ((w & FUMASKRISC) == FU_REGONE) { if (eval < 0 || eval > 31) { @@ -734,7 +741,7 @@ int ResolveFixups(int sno) break; } - if ((w & 0x0F00) == FU_REGTWO) + if ((w & FUMASKRISC) == FU_REGTWO) { if (eval < 0 || eval > 31) { @@ -786,8 +793,9 @@ int ResolveFixups(int sno) // 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) @@ -837,27 +845,34 @@ int ResolveFixups(int sno) } } } +#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: @@ -872,6 +887,7 @@ int ResolveFixups(int sno) *locp |= (eval & 7) << 1; break; + // Fix up 6502 funny branch case FU_6BRA: eval -= (loc + 1); @@ -881,8 +897,10 @@ int ResolveFixups(int sno) *locp = (char)eval; break; + default: - interror(4); // Bad fixup type + // Bad fixup type--this should *never* happen! + interror(4); // NOTREACHED } continue; @@ -896,3 +914,4 @@ range: return 0; } +