{
register int amode; // (Parsed) addressing mode
register int i;
- VALUE eval; // Expression value
+ uint32_t eval; // Expression value
WORD eattr; // Expression attributes
int zpreq; // 1, optimize instr to zero-page form
register char * p; // (Temp) string usage
int am0; // Addressing mode
int a0reg; // Register
TOKEN a0expr[EXPRSIZE]; // Expression
-VALUE a0exval; // Expression's value
+uint32_t a0exval; // Expression's value
WORD a0exattr; // Expression's attribute
int a0ixreg; // Index register
int a0ixsiz; // Index register size (and scale)
TOKEN a0oexpr[EXPRSIZE]; // Outer displacement expression
-VALUE a0oexval; // Outer displacement value
+uint32_t a0oexval; // Outer displacement value
WORD a0oexattr; // Outer displacement attribute
SYM * a0esym; // External symbol involved in expr
TOKEN a0bexpr[EXPRSIZE]; // Base displacement expression
-VALUE a0bexval; // Base displacement value
+uint32_t a0bexval; // Base displacement value
WORD a0bexattr; // Base displacement attribute
WORD a0bsize; // Base displacement size
WORD a0extension; // 020+ extension address word
int am1; // Addressing mode
int a1reg; // Register
TOKEN a1expr[EXPRSIZE]; // Expression
-VALUE a1exval; // Expression's value
+uint32_t a1exval; // Expression's value
WORD a1exattr; // Expression's attribute
int a1ixreg; // Index register
int a1ixsiz; // Index register size (and scale)
TOKEN a1oexpr[EXPRSIZE]; // Outer displacement expression
-VALUE a1oexval; // Outer displacement value
+uint32_t a1oexval; // Outer displacement value
WORD a1oexattr; // Outer displacement attribute
SYM * a1esym; // External symbol involved in expr
TOKEN a1bexpr[EXPRSIZE]; // Base displacement expression
-VALUE a1bexval; // Base displacement value
+uint32_t a1bexval; // Base displacement value
WORD a1bexattr; // Base displacement attribute
WORD a1bsize; // Base displacement size
WORD a1extension; // 020+ extension address word
int bfval1; //bfxxx / fmove value 1
int bfval2; //bfxxx / fmove value 2
TOKEN bf0expr[EXPRSIZE]; // Expression
-VALUE bf0exval; // Expression's value
+uint32_t bf0exval; // Expression's value
WORD bf0exattr; // Expression's attribute
SYM * bf0esym; // External symbol involved in expr
extern int am0, am1;
extern int a0reg, a1reg, a2reg;
extern TOKEN a0expr[], a1expr[];
-extern VALUE a0exval, a1exval;
+extern uint32_t a0exval, a1exval;
extern WORD a0exattr, a1exattr;
extern int a0ixreg, a1ixreg;
extern int a0ixsiz, a1ixsiz;
extern TOKEN a0oexpr[], a1oexpr[];
-extern VALUE a0oexval, a1oexval;
+extern uint32_t a0oexval, a1oexval;
extern WORD a0oexattr, a1oexattr;
extern SYM * a0esym, * a1esym;
-extern VALUE a0bexval, a1bexval;
+extern uint32_t a0bexval, a1bexval;
extern WORD a0bexattr, a1bexattr;
extern WORD a0bsize, a1bsize;
extern TOKEN a0bexpr[], a1bexpr[];
extern int bfparam2;
extern int bfval1;
extern int bfval2;
-extern VALUE bf0exval;
+extern uint32_t bf0exval;
// mnattr:
#define CGSPECIAL 0x8000 // Special (don't parse addr modes)
SYM * symbolPtr[1000000]; // Symbol pointers table
static long unused; // For supressing 'write' warnings
char buffer[256]; // Scratch buffer for messages
+int largestAlign[3] = { 2, 2, 2 }; // Largest alignment value seen per section
// Function prototypes
int d_unimpl(void);
int d_prgflags(void);
int d_opt(void);
int d_dsp(void);
+void SetLargestAlignment(int);
// Directive handler table
int (*dirtab[])() = {
};
+//
+// Set the largest alignment seen in the current section
+//
+void SetLargestAlignment(int size)
+{
+ if ((scattr & TEXT) && (largestAlign[0] < size))
+ largestAlign[0] = size;
+ else if ((scattr & DATA) && (largestAlign[1] < size))
+ largestAlign[1] = size;
+ else if ((scattr & BSS) && (largestAlign[2] < size))
+ largestAlign[2] = size;
+}
+
+
//
// .error - Abort compilation, printing an error message
//
//
int d_org(void)
{
- VALUE address;
+ uint32_t address;
if (!rgpu && !rdsp && !m6502)
return error(".org permitted only in gpu/dsp and 6502 sections");
int wordlong = 0; // WORD = 0, LONG = 1
int outtype = 0; // 0:hex, 1:decimal, 2:unsigned
- VALUE eval; // Expression value
+ uint32_t eval; // Expression value
WORD eattr; // Expression attributes
SYM * esym; // External symbol involved in expr.
TOKEN r_expr[EXPRSIZE];
unsigned lower2Bits = (rgpu || rdsp ? orgaddr : sloc) & 0x03;
unsigned bytesToSkip = (0x04 - lower2Bits) & 0x03;
SkipBytes(bytesToSkip);
+ SetLargestAlignment(4);
return 0;
}
unsigned lower3Bits = (rgpu || rdsp ? orgaddr : sloc) & 0x07;
unsigned bytesToSkip = (0x08 - lower3Bits) & 0x07;
SkipBytes(bytesToSkip);
+ SetLargestAlignment(8);
return 0;
}
unsigned lower4Bits = (rgpu || rdsp ? orgaddr : sloc) & 0x0F;
unsigned bytesToSkip = (0x10 - lower4Bits) & 0x0F;
SkipBytes(bytesToSkip);
+ SetLargestAlignment(16);
return 0;
}
unsigned lower5Bits = (rgpu || rdsp ? orgaddr : sloc) & 0x1F;
unsigned bytesToSkip = (0x20 - lower5Bits) & 0x1F;
SkipBytes(bytesToSkip);
+ SetLargestAlignment(32);
return 0;
}
//
// Return absolute (not TDB) and defined expression or return an error
//
-int abs_expr(VALUE * a_eval)
+int abs_expr(uint32_t * a_eval)
{
WORD eattr;
int d_assert(void)
{
WORD eattr;
- VALUE eval;
+ uint32_t eval;
for(; expr(exprbuf, &eval, &eattr, NULL)==OK; ++tok)
{
//
int d_prgflags(void)
{
- VALUE eval;
+ uint32_t eval;
if (*tok == EOL)
return error("PRGFLAGS requires value");
//
int d_abs(void)
{
- VALUE eval;
+ uint32_t eval;
if (m6502)
return error(in_6502mode);
{
DEBUG { printf("Directive: .ds.[size] = %u, sloc = $%X\n", siz, sloc); }
- VALUE eval;
+ uint32_t eval;
if (cursect != M6502)
{
// Check to see if the value being passed in is negative (who the hell does
// that?--nobody does; it's the code gremlins, or rum, that does it)
- // N.B.: Since VALUE is of type uint32_t, if it goes negative, it will have
+ // N.B.: Since 'eval' is of type uint32_t, if it goes negative, it will have
// its high bit set.
if (eval & 0x80000000)
return error("negative sizes not allowed");
}
else
{
- dep_block(eval, siz, (VALUE)0, (WORD)(DEFINED | ABS), NULL);
+ dep_block(eval, siz, 0, (WORD)(DEFINED | ABS), NULL);
}
at_eol();
int d_dc(WORD siz)
{
WORD eattr;
- VALUE eval;
+ uint32_t eval;
uint8_t * p;
if ((scattr & SBSS) != 0)
//
int d_dcb(WORD siz)
{
- VALUE evalc, eval;
+ uint32_t evalc, eval;
WORD eattr;
DEBUG { printf("dcb: section is %s%s%s (scattr=$%X)\n", (cursect & TEXT ? "TEXT" : ""), (cursect & DATA ? " DATA" : ""), (cursect & BSS ? "BSS" : ""), scattr); }
//
int d_init(WORD def_siz)
{
- VALUE count;
- VALUE eval;
+ uint32_t count;
+ uint32_t eval;
WORD eattr;
WORD siz;
//
// Deposit 'count' values of size 'siz' in the current (non-BSS) segment
//
-int dep_block(VALUE count, WORD siz, VALUE eval, WORD eattr, TOKEN * exprbuf)
+int dep_block(uint32_t count, WORD siz, uint32_t eval, WORD eattr, TOKEN * exprbuf)
{
WORD tdb;
WORD defined;
{
SYM * sym;
char * p;
- VALUE eval;
+ uint32_t eval;
if (m6502)
return error(in_6502mode);
//
int d_cargs(void)
{
- VALUE eval = 4; // Default to 4 if no offset specified (to account for
+ uint32_t eval = 4; // Default to 4 if no offset specified (to account for
// return address)
WORD rlist;
SYM * symbol;
//
int d_cstruct(void)
{
- VALUE eval = 0; // Default, if no offset specified, is zero
+ uint32_t eval = 0; // Default, if no offset specified, is zero
WORD rlist;
SYM * symbol;
char * symbolName;
int d_if(void)
{
WORD eattr;
- VALUE eval;
+ uint32_t eval;
SYM * esym;
IFENT * rif = f_ifent;
extern TOKEN exprbuf[];
extern SYM * symbolPtr[];
extern int (* dirtab[])();
+extern int largestAlign[];
// Exported functions
void auto_even(void);
-int dep_block(VALUE, WORD, VALUE, WORD, TOKEN *);
+int dep_block(uint32_t, WORD, uint32_t, WORD, TOKEN *);
int eject(void);
-int abs_expr(VALUE *);
+int abs_expr(uint32_t *);
int symlist(int(*)());
int d_even(void);
int eaNgen(WORD siz)
{
- VALUE vbd, v = aNexval;
+ uint32_t vbd, v = aNexval;
WORD wbd, w = (WORD)(aNexattr & DEFINED);
WORD tdbbd, tdb = (WORD)(aNexattr & TDB);
vbd = aNbdexval;
{
// Just deposit it
if ((aNexattr & TDB) == cursect)
- v -= (VALUE)sloc;
+ v -= (uint32_t)sloc;
else if ((aNexattr & TDB) != ABS)
error(rel_error);
{
// Deposit a byte...
if ((aNexattr & TDB) == cursect)
- v -= (VALUE)sloc;
+ v -= (uint32_t)sloc;
else if ((aNexattr & TDB) != ABS)
error(rel_error);
// N.B.: The size of tokenClass should be identical to the largest value of
// a token; we're assuming 256 but not 100% sure!
static char tokenClass[256]; // Generated table of token classes
-static VALUE evstk[EVSTACKSIZE]; // Evaluator value stack
+static uint32_t evstk[EVSTACKSIZE]; // Evaluator value stack
static WORD evattr[EVSTACKSIZE]; // Evaluator attribute stack
// Token-class initialization list
//
// Obtain a string value
//
-static VALUE str_value(char * p)
+static uint32_t str_value(char * p)
{
- VALUE v;
+ uint32_t v;
for(v=0; *p; p++)
v = (v << 8) | (*p & 0xFF);
//
// Recursive-descent expression analyzer (with some simple speed hacks)
//
-int expr(TOKEN * otk, VALUE * a_value, WORD * a_attr, SYM ** a_esym)
+int expr(TOKEN * otk, uint32_t * a_value, WORD * a_attr, SYM ** a_esym)
{
// Passed in values (once derefenced, that is) can all be zero. They are
// there so that the expression analyzer can fill them in as needed. The
// UNDEFINED, but it's value includes everything but the symbol value, and
// `a_esym' is set to the external symbol.
//
-int evexpr(TOKEN * tk, VALUE * a_value, WORD * a_attr, SYM ** a_esym)
+int evexpr(TOKEN * tk, uint32_t * a_value, WORD * a_attr, SYM ** a_esym)
{
WORD attr;
SYM * sy;
- VALUE * sval = evstk; // (Empty) initial stack
+ uint32_t * sval = evstk; // (Empty) initial stack
WORD * sattr = evattr;
SYM * esym = NULL; // No external symbol involved
WORD sym_seg = 0;
// Compiler is picky here: Without casting these, it discards
// the sign if dividing a negative # by a positive one,
// creating a bad result. :-/
- // Probably a side effect of using VALUE intead of ints.
- *sval = (int)sval[0] / (int)sval[1];
+ // Definitely a side effect of using uint32_ts intead of ints.
+ *sval = (int32_t)sval[0] / (int32_t)sval[1];
//printf("%i\n", *sval);
break;
case '%':
void InitExpression(void);
int expr1(void);
int expr2(void);
-int expr(TOKEN *, VALUE *, WORD *, SYM **);
-int evexpr(TOKEN *, VALUE *, WORD *, SYM **);
+int expr(TOKEN *, uint32_t *, WORD *, SYM **);
+int evexpr(TOKEN *, uint32_t *, WORD *, SYM **);
#endif // __EXPR_H__
//
// Return GEMDOS format date
//
-VALUE dos_date(void)
+uint32_t dos_date(void)
{
- VALUE v;
+ uint32_t v;
struct tm * tm;
time_t tloc;
//
// Return GEMDOS format time
//
-VALUE dos_time(void)
+uint32_t dos_time(void)
{
- VALUE v;
+ uint32_t v;
struct tm * tm;
time_t tloc;
//
// Generate a time string
//
-void time_string(char * buf, VALUE time)
+void time_string(char * buf, uint32_t time)
{
int hour;
char * ampm;
//
// Generate a date string
//
-void date_string(char * buf, VALUE date)
+void date_string(char * buf, uint32_t date)
{
sprintf(buf, "%d-%s-%d",
(int)(date & 0x1F), month[(date >> 5) & 0xF], (int)((date >> 9) + 1980));
//
// Output a value to listing
//
-int listvalue(VALUE v)
+int listvalue(uint32_t v)
{
sprintf(buf, "=%08X", v);
strncpy(lnimage + DATA_COL - 1, buf, 9);
// Exported functions
int eject(void);
-VALUE dos_date(void);
-VALUE dos_time(void);
+uint32_t dos_date(void);
+uint32_t dos_time(void);
void taglist(char);
void println(const char *);
void ship_ln(const char *);
void InitListing(void);
void listeol(void);
void lstout(char);
-int listvalue(VALUE);
+int listvalue(uint32_t);
int d_subttl(void);
int d_title(void);
int m_dbra(WORD inst, WORD siz)
{
- VALUE v;
+ uint32_t v;
siz = siz;
inst |= a0reg;
//
int m_br(WORD inst, WORD siz)
{
- VALUE v;
+ uint32_t v;
if (a0exattr & DEFINED)
{
//
int m_movem(WORD inst, WORD siz)
{
- VALUE eval;
+ uint32_t eval;
WORD i;
WORD w;
WORD rmask;
if ((a0exattr & TDB) != cursect)
return error(rel_error);
- VALUE v = a0exval - (sloc + 2);
+ uint32_t v = a0exval - (sloc + 2);
D_word(inst);
D_long(v);
if ((a0exattr & TDB) != cursect)
return error(rel_error);
- VALUE v = a0exval - (sloc + 2);
+ uint32_t v = a0exval - (sloc + 2);
// Optimize branch instr. size
if (siz == SIZL)
{
CHECK00;
- VALUE v;
+ uint32_t v;
WORD condition = inst & 0x1f; // Grab condition sneakily placed in the lower 5 bits of inst
inst &= 0xffe0; // And then mask them out - you ain't seen me, roit?
return error(undef_error);
if (a0exval + 0x8000 > 0x10000)
- return error("");
+ return error("");
if (*tok != EOL)
return error(extra_stuff);
D_word((a0exval & 0xffff));
-
+
return OK;
// hardcoded in 68ktab but there is aliasing
// between 68030 and 68040 opcode. So we just
// set the 3 lower bits to 1 in pflushn inside
- // 68ktab and detect it here.
+ // 68ktab and detect it here.
inst = (inst & 0xff8) | 8;
inst |= (tok[1] & 7) | (5 << 8);
if (tok[3] != EOL)
// a 68020 + 68551 socket and since this is
// an Atari targetted assembler....
CHECKNO30;
-
+
inst |= am1;
D_word(inst);
D_word(inst);
ea1gen(siz);
-
+
return OK;
}
if ((a1exattr & TDB) != cursect)
return error(rel_error);
- VALUE v = a1exval - sloc;
+ uint32_t v = a1exval - sloc;
if ((v + 0x8000) > 0x10000)
return error(range_error);
static LONG macuniq; // Unique-per-macro number
static SYM * curmac; // Macro currently being defined
-static VALUE argno; // Formal argument count
+static uint32_t argno; // Formal argument count
static LLIST * firstrpt; // First .rept line
static LLIST * nextrpt; // Last .rept line
//
int HandleRept(void)
{
- VALUE eval;
+ uint32_t eval;
// Evaluate repeat expression
if (abs_expr(&eval) != OK)
#include "object.h"
#include "6502.h"
+#include "direct.h"
#include "error.h"
#include "mark.h"
#include "riscasm.h"
{
elfHdrNum[ES_TEXT] = shstIndex;
shstTab[ES_TEXT] = shstSize;
- shstSize += DepositELFSHSTEntry(&shstPtr, "TEXT");
+ shstSize += DepositELFSHSTEntry(&shstPtr, ".text");
shstIndex++;
numEntries++;
}
{
elfHdrNum[ES_DATA] = shstIndex;
shstTab[ES_DATA] = shstSize;
- shstSize += DepositELFSHSTEntry(&shstPtr, "DATA");
+ shstSize += DepositELFSHSTEntry(&shstPtr, ".data");
shstIndex++;
numEntries++;
}
{
elfHdrNum[ES_BSS] = shstIndex;
shstTab[ES_BSS] = shstSize;
- shstSize += DepositELFSHSTEntry(&shstPtr, "BSS");
+ shstSize += DepositELFSHSTEntry(&shstPtr, ".bss");
shstIndex++;
numEntries++;
}
// Construct TEXT section, if any
if (sect[TEXT].sloc > 0)
{
- headerSize += DepositELFSectionHeader(headers + headerSize, shstTab[ES_TEXT], 1, 6, 0, elfSize, sect[TEXT].sloc, 0, 0, 2, 0);
+ headerSize += DepositELFSectionHeader(headers + headerSize, shstTab[ES_TEXT], 1, 6, 0, elfSize, sect[TEXT].sloc, 0, 0, largestAlign[0], 0);
for(CHUNK * cp=sect[TEXT].sfcode; cp!=NULL; cp=cp->chnext)
{
// Construct DATA section, if any
if (sect[DATA].sloc > 0)
{
- headerSize += DepositELFSectionHeader(headers + headerSize, shstTab[ES_DATA], 1, 3, 0, elfSize, sect[DATA].sloc, 0, 0, 1, 0);
+ headerSize += DepositELFSectionHeader(headers + headerSize, shstTab[ES_DATA], 1, 3, 0, elfSize, sect[DATA].sloc, 0, 0, largestAlign[1], 0);
for(CHUNK * cp=sect[DATA].sfcode; cp!=NULL; cp=cp->chnext)
{
// Construct BSS section, if any
if (sect[BSS].sloc > 0)
{
- headerSize += DepositELFSectionHeader(headers + headerSize, shstTab[ES_BSS], 8, 3, 0, elfSize, sect[BSS].sloc, 0, 0, 2, 0);
+ headerSize += DepositELFSectionHeader(headers + headerSize, shstTab[ES_BSS], 8, 3, 0, elfSize, sect[BSS].sloc, 0, 0, largestAlign[2], 0);
}
int textrelLoc = headerSize;
IFENT * f_ifent; // Freelist of ifents
int disabled; // Assembly conditionally disabled
int just_bss; // 1, ds.b in microprocessor mode
-VALUE pcloc; // Value of "PC" at beginning of line
+uint32_t pcloc; // Value of "PC" at beginning of line
SYM * lab_sym; // Label on line (or NULL)
const char extra_stuff[] = "extra (unexpected) text found after addressing mode";
char * equate; // Symbol (or NULL)
int labtyp = 0; // Label type (':', DCOLON)
int equtyp = 0; // Equ type ('=', DEQUALS)
- VALUE eval; // Expression value
+ uint32_t eval; // Expression value
WORD eattr; // Expression attributes
SYM * esym; // External symbol involved in expr.
WORD siz = 0; // Size suffix to mnem/diretve/macro
lab_sym = NULL; // No (exported) label
equate = NULL; // No equate
tk = tok; // Save first token in line
- pcloc = (VALUE)sloc; // Set beginning-of-line PC
+ pcloc = (uint32_t)sloc; // Set beginning-of-line PC
loop1: // Internal line processing loop
if (reglist(&rmask) < 0)
goto loop;
- eval = (VALUE)rmask;
+ eval = (uint32_t)rmask;
eattr = ABS | DEFINED;
}
else if (equtyp == CCDEF)
extern const char syntax_error[];
extern const char extra_stuff[];
extern int just_bss;
-extern VALUE pcloc;
+extern uint32_t pcloc;
extern SYM * lab_sym;
extern LONG amsktab[];
extern IFENT * ifent;
//
int GetRegister(WORD rattr)
{
- VALUE eval; // Expression value
+ uint32_t eval; // Expression value
WORD eattr; // Expression attributes
SYM * esym; // External symbol involved in expr.
TOKEN r_expr[EXPRSIZE]; // Expression token list
WORD attrflg;
int indexed; // Indexed register flag
- VALUE eval; // Expression value
+ uint32_t eval; // Expression value
WORD eattr; // Expression attributes
SYM * esym; // External symbol involved in expr.
TOKEN r_expr[EXPRSIZE]; // Expression token list
}
sy->sattr = DEFINED | EQUATED | ABS;
- sy->svalue = (*s ? (VALUE)atoi(s) : 0);
+ sy->svalue = (*s ? (uint32_t)atoi(s) : 0);
break;
case 'e': // Redirect error message output
case 'E':
#define SPACE ' ' // ASCII space
#define SLASHCHAR '/'
#define SLASHSTRING "/"
-#define VALUE uint32_t // Assembler value
#define TOKEN uint32_t // Assembler token
#define FNSIZ 128 // Maximum size of a filename
#define OK 0 // OK return
int ResolveFixups(int sno)
{
PTR fup; // Current fixup
- VALUE eval; // Expression value
+ uint32_t eval; // Expression value
SYM * sy; // (Temp) pointer to a symbol
uint16_t i; // (Temp) word
int reg2;
if (eattr & DEFINED)
{
if (tdb == sno)
- eval -= (VALUE)loc;
+ eval -= (uint32_t)loc;
else if (tdb)
{
error("PC-relative expr across sections");
warn("unoptimized short branch");
}
else if (obj_format == MWC)
- eval -= (VALUE)loc;
+ eval -= (uint32_t)loc;
tdb = 0;
eattr &= ~TDB;
int state = 0; // State for keyword detector
int j = 0; // Var for keyword detector
uint8_t c; // Random char
- VALUE v; // Random value
+ uint32_t v; // Random value
uint8_t * nullspot = NULL; // Spot to clobber for SYMBOL termination
int stuffnull; // 1:terminate SYMBOL '\0' at *nullspot
uint8_t c1;
if (((chrtab[*ln] & DOT) == 0) || (dotxtab[*ln] == 0))
return error("[bwsl] must follow '.' in symbol");
- v = (VALUE)dotxtab[*ln++];
+ v = (uint32_t)dotxtab[*ln++];
if (chrtab[*ln] & CTSYM)
return error("misuse of '.'; not allowed in symbols");
IREPT {
LLIST * ir_firstln; // Pointer to first line
LLIST * ir_nextln; // Pointer to next line
- VALUE ir_count; // Repeat count (decrements)
+ uint32_t ir_count; // Repeat count (decrements)
};
// Exported variables
// RMAC derived from MADMAC v1.07 Written by Landon Dyer, 1986
// Source utilised with the kind permission of Landon Dyer
//
-// Contributors: James Hammons, George Nakos, Graeme Hinchliffe, SCPCD
+// Contributors: James Hammons, George Nakos, Graeme Hinchliffe, SCPCD, SainT
//
#ifndef __VERSION_H__
#define MAJOR 1 // Major version number
#define MINOR 8 // Minor version number
-#define PATCH 4 // Patch release number
+#define PATCH 5 // Patch release number
#endif // __VERSION_H__
projects / rmac / commitdiff