X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?p=rmac;a=blobdiff_plain;f=sect.c;h=ab5c4aab8dc831a56539c65f04d0231c3d637175;hp=21591a0219146b127a7321dbd07dcea4cab0ba1f;hb=ec655dd3711a3cf470e90ba1f12a8206f7df3fd3;hpb=9fb8931331db981c04e062a3ad36c0d79acb30ae

diff --git a/sect.c b/sect.c
index 21591a0..ab5c4aa 100644
--- a/sect.c
+++ b/sect.c
@@ -13,34 +13,34 @@
 #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 
 
-// BOLLOCKS
-//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.
@@ -69,9 +69,32 @@ static char fusizoffs[] = {
 
 
 //
-// Make a New (Clean) Section
+// Initialize sections; setup initial ABS, TEXT, DATA and BSS sections
+//
+void InitSection(void)
+{
+	int i;
+
+	// Cleanup all sections
+	for(i=0; i<NSECTS; i++)
+		MakeSection(i, 0);
+
+	// Construct default sections, make TEXT the current section
+	MakeSection(ABS,  SUSED | SABS | SBSS);		// ABS
+	MakeSection(TEXT, SUSED | TEXT       );		// TEXT
+	MakeSection(DATA, SUSED | DATA       );		// DATA
+	MakeSection(BSS,  SUSED | BSS  | SBSS);		// BSS
+//	MakeSection(M6502, SUSED | TEXT       );		// 6502 code section
+
+	// Switch to TEXT for starters
+	SwitchSection(TEXT);
+}
+
+
+//
+// Make a new (clean) section
 //
-void mksect(int sno, WORD attr)
+void MakeSection(int sno, WORD attr)
 {
 	SECT * p = &sect[sno];
 	p->scattr = attr;
@@ -82,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 = &sect[sno];
 
-	scattr = p->scattr;						// Copy section vars
+	// Copy section vars
+	scattr = p->scattr;
 	sloc = p->sloc;
 	scode = p->scode;
 	sfix = p->sfix;
@@ -119,9 +143,9 @@ void switchsect(int sno)
 
 
 //
-// Save Current Section
+// Save current section
 //
-void savsect(void)
+void SaveSection(void)
 {
 	SECT * p = &sect[cursect];
 
@@ -136,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; i<NSECTS; i++)
-		mksect(i, 0);
-
-	// Construct default sections, make TEXT the current section
-	mksect(ABS,   SUSED | SABS | SBSS);		// ABS
-	mksect(TEXT,  SUSED | TEXT       );		// TEXT
-	mksect(DATA,  SUSED | DATA       );		// DATA
-	mksect(BSS,   SUSED | BSS | SBSS );		// BSS
-//	mksect(M6502, SUSED | TEXT       );		// 6502 code section
-
-	switchsect(TEXT);						// Switch to TEXT for starters
-}
-
-
 //
 // Test to see if a location has a fixup sic'd on it.  This is used by the
 // listing generator to print 'xx's instead of '00's for forward references
@@ -170,11 +172,12 @@ int fixtest(int sno, LONG loc)
 	WORD w;
 	LONG xloc;
 
-	stopmark();								// Force update to sect[] variables
+	// Force update to sect[] variables
+	StopMark();
 
-	// Hairy, ugly linear search for a mark on our location;
-	// the speed doesn't matter, since this is only done when generating a
-	// listing, which is SLOW.
+	// Hairy, ugly linear search for a mark on our location; the speed doesn't
+	// matter, since this is only done when generating a listing, which is
+	// SLOW.
 	for(ch=sect[sno].sffix; ch!=NULL; ch=ch->chnext)
 	{
 		fup.cp = (char *)ch->chptr;
@@ -195,7 +198,7 @@ int fixtest(int sno, LONG loc)
 				fup.lp += w;
 			}
 			else
-				++fup.lp;
+				fup.lp++;
 		}
 	}
 
@@ -204,11 +207,11 @@ 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)
 {
@@ -257,20 +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.
-#warning "!!! fixup() is filled with VOODOO !!!"
+	// 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
@@ -279,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++)
@@ -307,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 = &sect[cursect];
@@ -355,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;
@@ -372,7 +381,7 @@ int fixup(WORD attr, LONG loc, TOKEN * fexpr)
 
 
 //
-// Resolve all Fixups
+// Resolve all fixups
 //
 int ResolveAllFixups(void)
 {
@@ -381,55 +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);
 
-//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++)
-	{
-		if (fwdjump[i])
-		{
-			err_setup();
-			sprintf(buf, "* \'jump\' at $%08X - destination address is external to this source file and cannot have its aligment validated", fwdjump[i]);
-
-			if (listing > 0)
-				ship_ln(buf);
-
-			if (err_flag)
-				write(err_fd, buf, (LONG)strlen(buf));
-			else
-				printf("%s\n", buf);
-		}
-	}
-#endif
-
 	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;
@@ -444,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
@@ -481,7 +470,8 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); }
 
 				if (cch == NULL)
 				{
-					interror(7);			// Fixup (loc) out of range 
+					// Fixup (loc) out of range 
+					interror(7);
 					// NOTREACHED
 				}
 			}
@@ -522,14 +512,20 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); }
 
 			// 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
 			// 
@@ -625,7 +621,7 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); }
 			// 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++;
 
@@ -685,7 +681,7 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); }
 					break;
 				}
 
-				if ((w & 0x0F00) == FU_NUM15)
+				if ((w & FUMASKRISC) == FU_NUM15)
 				{
 					if (eval < -16 || eval > 15)
 					{
@@ -699,7 +695,7 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); }
 					break;
 				}
 
-				if ((w & 0x0F00) == FU_NUM31)
+				if ((w & FUMASKRISC) == FU_NUM31)
 				{
 					if (eval < 0 || eval > 31)
 					{
@@ -713,7 +709,7 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); }
 					break;
 				}
 
-				if ((w & 0x0F00) == FU_NUM32)
+				if ((w & FUMASKRISC) == FU_NUM32)
 				{
 					if (eval < 1 || eval > 32)
 					{
@@ -731,7 +727,7 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); }
 					break;
 				}
 
-				if ((w & 0x0F00) == FU_REGONE)
+				if ((w & FUMASKRISC) == FU_REGONE)
 				{
 					if (eval < 0 || eval > 31)
 					{
@@ -745,7 +741,7 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); }
 					break;
 				}
 
-				if ((w & 0x0F00) == FU_REGTWO)
+				if ((w & FUMASKRISC) == FU_REGTWO)
 				{
 					if (eval < 0 || eval > 31)
 					{
@@ -797,7 +793,7 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); }
 			// 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;
@@ -851,6 +847,7 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); }
 					}
 #endif
 
+					// Long constant in MOVEI # is word-swapped, so fix it here
 					eval = ((eval >> 16) & 0x0000FFFF) | ((eval << 16) & 0xFFFF0000);
 					flags = (MLONG | MMOVEI);
 				}
@@ -902,7 +899,8 @@ DEBUG { printf("ResolveFixups: cfileno=%u\n", cfileno); }
 				break;
 
 			default:
-				interror(4);                                 // Bad fixup type
+				// Bad fixup type--this should *never* happen!
+				interror(4);
 				// NOTREACHED
 			}
 			continue;