Cleanup of codebase and initial commit of 56K assembler by ggn.

[rmac] / sect.c

diff --git a/sect.c b/sect.c
index 5d7fb4ad22b31b87efa3784c897533f63a17519d..b076ca6a313dddaa9db58087ab1aac65f34b63fb 100644 (file)
--- a/sect.c
+++ b/sect.c
@@ -91,12 +91,12 @@ void InitSection(void)
 //
 void MakeSection(int sno, uint16_t attr)
 {
-       SECT * p = &sect[sno];
-       p->scattr = attr;
-       p->sloc = 0;
-       p->orgaddr = 0;
-       p->scode = p->sfcode = NULL;
-       p->sfix = p->sffix = NULL;
+       SECT * sp = &sect[sno];
+       sp->scattr = attr;
+       sp->sloc = 0;
+       sp->orgaddr = 0;
+       sp->scode = sp->sfcode = NULL;
+       sp->sfix = sp->sffix = NULL;
 }
 
 
@@ -108,15 +108,15 @@ void SwitchSection(int sno)
 {
        CHUNK * cp;
        cursect = sno;
-       SECT * p = &sect[sno];
+       SECT * sp = &sect[sno];
 
        m6502 = (sno == M6502); // Set 6502-mode flag
 
        // Copy section vars
-       scattr = p->scattr;
-       sloc = p->sloc;
-       scode = p->scode;
-       orgaddr = p->orgaddr;
+       scattr = sp->scattr;
+       sloc = sp->sloc;
+       scode = sp->scode;
+       orgaddr = sp->orgaddr;
 
        // Copy code chunk vars
        if ((cp = scode) != NULL)
@@ -126,6 +126,12 @@ void SwitchSection(int sno)
                chptr = cp->chptr + ch_size;
 
                // For 6502 mode, add the last org'd address
+// Why?
+/*
+Because the way this is set up it treats the 6502 assembly space as a single 64K space (+ 16 bytes, for some reason) and just bobbles around inside that space and uses a stack of org "pointers" to show where the data ended up.
+
+This is a piss poor way to handle things, and for fucks sake, we can do better than this!
+*/
                if (m6502)
                        chptr = cp->chptr + orgaddr;
        }
@@ -139,11 +145,11 @@ void SwitchSection(int sno)
 //
 void SaveSection(void)
 {
-       SECT * p = &sect[cursect];
+       SECT * sp = &sect[cursect];
 
-       p->scattr = scattr;                             // Bailout section vars
-       p->sloc = sloc;
-       p->orgaddr = orgaddr;
+       sp->scattr = scattr;                    // Bailout section vars
+       sp->sloc = sloc;
+       sp->orgaddr = orgaddr;
 
        if (scode != NULL)                              // Bailout code chunk
                scode->ch_size = ch_size;
@@ -701,16 +707,8 @@ int ResolveFixups(int sno)
                        SETBE32(locp, 0, eval);
                        break;
 
-               // Fixup QUAD forward references
-               // Need to add flags for OP uses... [DONE]
+               // Fixup QUAD forward references (mainly used by the OP assembler)
                case FU_QUAD:
-                       // If the symbol is undefined, make sure to pass the symbol in
-                       // to the MarkRelocatable() function.
-/*                     if (!(eattr & DEFINED))
-                               MarkRelocatable(sno, loc, 0, MQUAD, esym);
-                       else if (tdb)
-                               MarkRelocatable(sno, loc, tdb, MQUAD, NULL);//*/
-
                        if (w & FU_OBJLINK)
                        {
                                uint64_t quad = GETBE64(locp, 0);
@@ -719,13 +717,15 @@ int ResolveFixups(int sno)
                                if (fup->orgaddr)
                                        addr = fup->orgaddr;
 
-//printf("sect.c: FU_OBJLINK quad=%016lX, addr=%016lX ", quad, addr);
-
                                eval = (quad & 0xFFFFFC0000FFFFFFLL) | ((addr & 0x3FFFF8) << 21);
-//printf("(%016lX)\n", eval);
                        }
                        else if (w & FU_OBJDATA)
                        {
+                               // If it's in a TEXT or DATA section, be sure to mark for a
+                               // fixup later
+                               if (tdb)
+                                       MarkRelocatable(sno, loc, tdb, MQUAD, NULL);
+
                                uint64_t quad = GETBE64(locp, 0);
                                uint64_t addr = eval;
 
@@ -736,7 +736,6 @@ int ResolveFixups(int sno)
                        }
 
                        SETBE64(locp, 0, eval);
-//printf("(%016lX)\n", eval);
                        break;
 
                // Fixup a 3-bit "QUICK" reference in bits 9..1