Fixed regression in RISC JR cc, <label> handling.

[rmac] / sect.c

diff --git a/sect.c b/sect.c
index 1046588fd31e073351f6d363beb75e74a4da5a20..f797300395474822bef6688f02c9fabfd8f9846a 100644 (file)
--- a/sect.c
+++ b/sect.c
@@ -17,52 +17,53 @@
 #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
+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
 };
 
 
@@ -210,6 +211,7 @@ int fixtest(int sno, LONG loc)
 //
 int chcheck(LONG amt)
 {
+       DEBUG { printf("chcheck(%u)\n", amt); }
        // If in BSS section, no allocation required
        if (scattr & SBSS)
                return 0;
@@ -217,12 +219,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 = &sect[cursect];
        CHUNK * cp = malloc(sizeof(CHUNK) + amt);
 
@@ -451,6 +455,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;