Version bump to 1.9.0. Right now the only thing that supports it is
dc.d; now that the infrastructure supports it, anything else that needs
64-bit support (such as FPUs and the like) can be done very easily now.
16 files changed:
{
register int amode; // (Parsed) addressing mode
register int i;
{
register int amode; // (Parsed) addressing mode
register int i;
- uint32_t eval; // Expression value
+ uint64_t eval; // Expression value
WORD eattr; // Expression attributes
int zpreq; // 1, optimize instr to zero-page form
register char * p; // (Temp) string usage
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
int am0; // Addressing mode
int a0reg; // Register
TOKEN a0expr[EXPRSIZE]; // Expression
-uint32_t a0exval; // Expression's value
+uint64_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
WORD a0exattr; // Expression's attribute
int a0ixreg; // Index register
int a0ixsiz; // Index register size (and scale)
TOKEN a0oexpr[EXPRSIZE]; // Outer displacement expression
-uint32_t 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
WORD a0oexattr; // Outer displacement attribute
SYM * a0esym; // External symbol involved in expr
TOKEN a0bexpr[EXPRSIZE]; // Base displacement expression
-uint32_t a0bexval; // Base displacement value
+uint64_t a0bexval; // Base displacement value
WORD a0bexattr; // Base displacement attribute
WORD a0bsize; // Base displacement size
WORD a0extension; // 020+ extension address word
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
int am1; // Addressing mode
int a1reg; // Register
TOKEN a1expr[EXPRSIZE]; // Expression
-uint32_t a1exval; // Expression's value
+uint64_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
WORD a1exattr; // Expression's attribute
int a1ixreg; // Index register
int a1ixsiz; // Index register size (and scale)
TOKEN a1oexpr[EXPRSIZE]; // Outer displacement expression
-uint32_t 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
WORD a1oexattr; // Outer displacement attribute
SYM * a1esym; // External symbol involved in expr
TOKEN a1bexpr[EXPRSIZE]; // Base displacement expression
-uint32_t a1bexval; // Base displacement value
+uint64_t a1bexval; // Base displacement value
WORD a1bexattr; // Base displacement attribute
WORD a1bsize; // Base displacement size
WORD a1extension; // 020+ extension address word
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
int bfval1; //bfxxx / fmove value 1
int bfval2; //bfxxx / fmove value 2
TOKEN bf0expr[EXPRSIZE]; // Expression
-uint32_t bf0exval; // Expression's value
+uint64_t bf0exval; // Expression's value
WORD bf0exattr; // Expression's attribute
SYM * bf0esym; // External symbol involved in expr
WORD bf0exattr; // Expression's attribute
SYM * bf0esym; // External symbol involved in expr
+ tok++; // Skip the HI LONG
tok++;
bfval1 = *(int *)tok;
tok++;
bfval1 = *(int *)tok;
+ tok++; // Skip the HI LONG
tok++;
bfval2 = *(int *)tok;
tok++;
bfval2 = *(int *)tok;
extern int am0, am1;
extern int a0reg, a1reg, a2reg;
extern TOKEN a0expr[], a1expr[];
extern int am0, am1;
extern int a0reg, a1reg, a2reg;
extern TOKEN a0expr[], a1expr[];
-extern uint32_t a0exval, a1exval;
+extern uint64_t a0exval, a1exval;
extern WORD a0exattr, a1exattr;
extern int a0ixreg, a1ixreg;
extern int a0ixsiz, a1ixsiz;
extern WORD a0exattr, a1exattr;
extern int a0ixreg, a1ixreg;
extern int a0ixsiz, a1ixsiz;
extern uint32_t a0oexval, a1oexval;
extern WORD a0oexattr, a1oexattr;
extern SYM * a0esym, * a1esym;
extern uint32_t a0oexval, a1oexval;
extern WORD a0oexattr, a1oexattr;
extern SYM * a0esym, * a1esym;
-extern uint32_t a0bexval, a1bexval;
+extern uint64_t a0bexval, a1bexval;
extern WORD a0bexattr, a1bexattr;
extern WORD a0bsize, a1bsize;
extern TOKEN a0bexpr[], a1bexpr[];
extern WORD a0bexattr, a1bexattr;
extern WORD a0bsize, a1bsize;
extern TOKEN a0bexpr[], a1bexpr[];
extern int bfparam2;
extern int bfval1;
extern int bfval2;
extern int bfparam2;
extern int bfval1;
extern int bfval2;
-extern uint32_t bf0exval;
+extern uint64_t bf0exval;
// mnattr:
#define CGSPECIAL 0x8000 // Special (don't parse addr modes)
// mnattr:
#define CGSPECIAL 0x8000 // Special (don't parse addr modes)
+ printf("$%lX ", ((uint64_t)tp[0] << 32) | (uint64_t)tp[1]);
+ tp += 2;
break;
case ACONST:
printf("ACONST=($%X,$%X) ", *tp, tp[1]);
break;
case ACONST:
printf("ACONST=($%X,$%X) ", *tp, tp[1]);
switch ((int)*tk++)
{
case CONST: // CONST <value>
switch ((int)*tk++)
{
case CONST: // CONST <value>
- printf("CONST=%u", *tk++);
+ printf("CONST=%lu", ((uint64_t)tk[0] << 32) | (uint64_t)tk[1]);
+ tk += 2;
break;
case STRING: // STRING <address>
printf("STRING='%s'", string[*tk++]);
break;
case STRING: // STRING <address>
printf("STRING='%s'", string[*tk++]);
printf("[COLON]");
else if (*t == CONST)
{
printf("[COLON]");
else if (*t == CONST)
{
- t++;
- printf("[CONST: $%X]", (uint32_t)*t);
+ printf("[CONST: $%lX]", ((uint64_t)t[1] << 32) | (uint64_t)t[2]);
+ t += 2;
}
else if (*t == ACONST)
{
}
else if (*t == ACONST)
{
if (!rgpu && !rdsp && !m6502)
return error(".org permitted only in gpu/dsp and 6502 sections");
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
int wordlong = 0; // WORD = 0, LONG = 1
int outtype = 0; // 0:hex, 1:decimal, 2:unsigned
- uint32_t eval; // Expression value
+ uint64_t eval; // Expression value
WORD eattr; // Expression attributes
SYM * esym; // External symbol involved in expr.
TOKEN r_expr[EXPRSIZE];
WORD eattr; // Expression attributes
SYM * esym; // External symbol involved in expr.
TOKEN r_expr[EXPRSIZE];
//
// Return absolute (not TDB) and defined expression or return an error
//
//
// Return absolute (not TDB) and defined expression or return an error
//
-int abs_expr(uint32_t * a_eval)
+int abs_expr(uint64_t * a_eval)
int d_assert(void)
{
WORD eattr;
int d_assert(void)
{
WORD eattr;
for(; expr(exprbuf, &eval, &eattr, NULL)==OK; ++tok)
{
for(; expr(exprbuf, &eval, &eattr, NULL)==OK; ++tok)
{
//
int d_prgflags(void)
{
//
int d_prgflags(void)
{
if (*tok == EOL)
return error("PRGFLAGS requires value");
if (*tok == EOL)
return error("PRGFLAGS requires value");
if (m6502)
return error(in_6502mode);
if (m6502)
return error(in_6502mode);
{
DEBUG { printf("Directive: .ds.[size] = %u, sloc = $%X\n", siz, sloc); }
{
DEBUG { printf("Directive: .ds.[size] = %u, sloc = $%X\n", siz, sloc); }
int d_dc(WORD siz)
{
WORD eattr;
int d_dc(WORD siz)
{
WORD eattr;
uint8_t * p;
if ((scattr & SBSS) != 0)
uint8_t * p;
if ((scattr & SBSS) != 0)
+ // Shamus: Why can't we do longs in 6502 mode?
if (m6502)
return error(in_6502mode);
if (m6502)
return error(in_6502mode);
+ case SIZD:
+ // 64-bit size
+ // N.B.: May have to come up with section/fixup markers for this;
+ // ATM it's only used in dc.d statements...
+ D_long(eval >> 32);
+ D_long(eval & 0xFFFFFFFF);
+ break;
WORD eattr;
DEBUG { printf("dcb: section is %s%s%s (scattr=$%X)\n", (cursect & TEXT ? "TEXT" : ""), (cursect & DATA ? " DATA" : ""), (cursect & BSS ? "BSS" : ""), scattr); }
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)
{
//
int d_init(WORD def_siz)
{
- uint32_t count;
- uint32_t eval;
+ uint64_t count;
+ uint64_t eval;
if (m6502)
return error(in_6502mode);
if (m6502)
return error(in_6502mode);
- uint32_t eval = 4; // Default to 4 if no offset specified (to account for
+ uint64_t eval = 4; // Default to 4 if no offset specified (to account for
// return address)
WORD rlist;
SYM * symbol;
// return address)
WORD rlist;
SYM * symbol;
- uint32_t eval = 0; // Default, if no offset specified, is zero
+ uint64_t eval = 0; // Default, if no offset specified, is zero
WORD rlist;
SYM * symbol;
char * symbolName;
WORD rlist;
SYM * symbol;
char * symbolName;
int d_if(void)
{
WORD eattr;
int d_if(void)
{
WORD eattr;
SYM * esym;
IFENT * rif = f_ifent;
SYM * esym;
IFENT * rif = f_ifent;
void auto_even(void);
int dep_block(uint32_t, WORD, uint32_t, WORD, TOKEN *);
int eject(void);
void auto_even(void);
int dep_block(uint32_t, WORD, uint32_t, WORD, TOKEN *);
int eject(void);
-int abs_expr(uint32_t *);
+int abs_expr(uint64_t *);
int symlist(int(*)());
int d_even(void);
int symlist(int(*)());
int d_even(void);
// 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
// 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 uint32_t evstk[EVSTACKSIZE]; // Evaluator value stack
+static uint64_t evstk[EVSTACKSIZE]; // Evaluator value stack
static WORD evattr[EVSTACKSIZE]; // Evaluator attribute stack
// Token-class initialization list
static WORD evattr[EVSTACKSIZE]; // Evaluator attribute stack
// Token-class initialization list
{
case CR_ABSCOUNT:
*evalTokenBuffer++ = CONST;
{
case CR_ABSCOUNT:
*evalTokenBuffer++ = CONST;
+ *evalTokenBuffer++ = 0; // Set HI LONG to zero
*evalTokenBuffer++ = (LONG)sect[ABS].sloc;
break;
case CR_TIME:
*evalTokenBuffer++ = CONST;
*evalTokenBuffer++ = (LONG)sect[ABS].sloc;
break;
case CR_TIME:
*evalTokenBuffer++ = CONST;
+ *evalTokenBuffer++ = 0; // Set HI LONG to zero
*evalTokenBuffer++ = dos_time();
break;
case CR_DATE:
*evalTokenBuffer++ = CONST;
*evalTokenBuffer++ = dos_time();
break;
case CR_DATE:
*evalTokenBuffer++ = CONST;
+ *evalTokenBuffer++ = 0; // Set HI LONG to zero
*evalTokenBuffer++ = dos_date();
break;
case CR_MACDEF: // ^^macdef <macro-name>
*evalTokenBuffer++ = dos_date();
break;
case CR_MACDEF: // ^^macdef <macro-name>
p = string[*tok++];
w = (lookup(p, MACRO, 0) == NULL ? 0 : 1);
*evalTokenBuffer++ = CONST;
p = string[*tok++];
w = (lookup(p, MACRO, 0) == NULL ? 0 : 1);
*evalTokenBuffer++ = CONST;
+ *evalTokenBuffer++ = 0; // Set HI LONG to zero
*evalTokenBuffer++ = (TOKEN)w;
break;
case CR_DEFINED:
*evalTokenBuffer++ = (TOKEN)w;
break;
case CR_DEFINED:
j = (*p == '.' ? curenv : 0);
w = ((sy = lookup(p, LABEL, j)) != NULL && (sy->sattr & w) ? 1 : 0);
*evalTokenBuffer++ = CONST;
j = (*p == '.' ? curenv : 0);
w = ((sy = lookup(p, LABEL, j)) != NULL && (sy->sattr & w) ? 1 : 0);
*evalTokenBuffer++ = CONST;
+ *evalTokenBuffer++ = 0; // Set HI LONG to zero
*evalTokenBuffer++ = (TOKEN)w;
break;
case CR_STREQ:
*evalTokenBuffer++ = (TOKEN)w;
break;
case CR_STREQ:
w = (WORD)(!strcmp(p, p2));
*evalTokenBuffer++ = CONST;
w = (WORD)(!strcmp(p, p2));
*evalTokenBuffer++ = CONST;
+ *evalTokenBuffer++ = 0; // Set HI LONG to zero
*evalTokenBuffer++ = (TOKEN)w;
break;
}
*evalTokenBuffer++ = (TOKEN)w;
break;
}
{
case CONST:
*evalTokenBuffer++ = CONST;
{
case CONST:
*evalTokenBuffer++ = CONST;
- *evalTokenBuffer++ = *tok++;
+ *evalTokenBuffer++ = *tok++; // HI LONG of constant
+ *evalTokenBuffer++ = *tok++; // LO LONG of constant
break;
case SYMBOL:
p = string[*tok++];
break;
case SYMBOL:
p = string[*tok++];
break;
case STRING:
*evalTokenBuffer++ = CONST;
break;
case STRING:
*evalTokenBuffer++ = CONST;
+ *evalTokenBuffer++ = 0; // Set HI LONG to zero
*evalTokenBuffer++ = str_value(string[*tok++]);
break;
case '(':
*evalTokenBuffer++ = str_value(string[*tok++]);
break;
case '(':
//
// Recursive-descent expression analyzer (with some simple speed hacks)
//
//
// Recursive-descent expression analyzer (with some simple speed hacks)
//
-int expr(TOKEN * otk, uint32_t * a_value, WORD * a_attr, SYM ** a_esym)
+int expr(TOKEN * otk, uint64_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
{
// 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
int j;
evalTokenBuffer = otk; // Set token pointer to 'exprbuf' (direct.c)
int j;
evalTokenBuffer = otk; // Set token pointer to 'exprbuf' (direct.c)
- // Also set in various other places too (riscasm.c, e.g.)
+ // Also set in various other places too (riscasm.c,
+ // e.g.)
//printf("expr(): tokens 0-2: %i %i %i (%c %c %c); tc[2] = %i\n", tok[0], tok[1], tok[2], tok[0], tok[1], tok[2], tokenClass[tok[2]]);
// Optimize for single constant or single symbol.
//printf("expr(): tokens 0-2: %i %i %i (%c %c %c); tc[2] = %i\n", tok[0], tok[1], tok[2], tok[0], tok[1], tok[2], tokenClass[tok[2]]);
// Optimize for single constant or single symbol.
// Seems that even other tokens (SUNARY type) can fuck this up too.
// if ((tok[1] == EOL)
if ((tok[1] == EOL && (tok[0] != CONST && tokenClass[tok[0]] != SUNARY))
// Seems that even other tokens (SUNARY type) can fuck this up too.
// if ((tok[1] == EOL)
if ((tok[1] == EOL && (tok[0] != CONST && tokenClass[tok[0]] != SUNARY))
- || (((*tok == CONST || *tok == SYMBOL) || (*tok >= KW_R0 && *tok <= KW_R31))
- && (tokenClass[tok[2]] < UNARY)))
+// || (((*tok == CONST || *tok == SYMBOL) || (*tok >= KW_R0 && *tok <= KW_R31))
+// && (tokenClass[tok[2]] < UNARY)))
+ || (((tok[0] == SYMBOL) || (tok[0] >= KW_R0 && tok[0] <= KW_R31))
+ && (tokenClass[tok[2]] < UNARY))
+ || ((tok[0] == CONST) && (tokenClass[tok[3]] < UNARY))
+ )
{
if (*tok >= KW_R0 && *tok <= KW_R31)
{
*evalTokenBuffer++ = CONST;
{
if (*tok >= KW_R0 && *tok <= KW_R31)
{
*evalTokenBuffer++ = CONST;
+ *evalTokenBuffer++ = 0; // Set HI LONG to zero
*evalTokenBuffer++ = *a_value = (*tok - KW_R0);
*a_attr = ABS | DEFINED;
*evalTokenBuffer++ = *a_value = (*tok - KW_R0);
*a_attr = ABS | DEFINED;
else if (*tok == CONST)
{
*evalTokenBuffer++ = CONST;
else if (*tok == CONST)
{
*evalTokenBuffer++ = CONST;
- *evalTokenBuffer++ = *a_value = tok[1];
+ *evalTokenBuffer++ = tok[1];
+ *evalTokenBuffer++ = tok[2];
+ *a_value = (((uint64_t)tok[1]) << 32) | tok[2];
*a_attr = ABS | DEFINED;
if (a_esym != NULL)
*a_esym = NULL;
*a_attr = ABS | DEFINED;
if (a_esym != NULL)
*a_esym = NULL;
//printf("Quick eval in expr(): CONST = %i, tokenClass[tok[2]] = %i\n", *a_value, tokenClass[*tok]);
}
else if (*tok == '*')
{
*evalTokenBuffer++ = CONST;
//printf("Quick eval in expr(): CONST = %i, tokenClass[tok[2]] = %i\n", *a_value, tokenClass[*tok]);
}
else if (*tok == '*')
{
*evalTokenBuffer++ = CONST;
+ *evalTokenBuffer++ = 0; // Set HI LONG to zero
if (orgactive)
*evalTokenBuffer++ = *a_value = orgaddr;
if (orgactive)
*evalTokenBuffer++ = *a_value = orgaddr;
// UNDEFINED, but it's value includes everything but the symbol value, and
// `a_esym' is set to the external symbol.
//
// UNDEFINED, but it's value includes everything but the symbol value, and
// `a_esym' is set to the external symbol.
//
-int evexpr(TOKEN * tk, uint32_t * a_value, WORD * a_attr, SYM ** a_esym)
+int evexpr(TOKEN * tk, uint64_t * a_value, WORD * a_attr, SYM ** a_esym)
- uint32_t * sval = evstk; // (Empty) initial stack
+ uint64_t * sval = evstk; // (Empty) initial stack
WORD * sattr = evattr;
SYM * esym = NULL; // No external symbol involved
WORD sym_seg = 0;
WORD * sattr = evattr;
SYM * esym = NULL; // No external symbol involved
WORD sym_seg = 0;
sym_seg = (WORD)(sy->sattr & TDB);
break;
case CONST:
sym_seg = (WORD)(sy->sattr & TDB);
break;
case CONST:
-//printf("evexpr(): CONST = %i\n", *tk);
- *++sval = *tk++; // Push value
+ *++sval = ((uint64_t)*tk++) << 32; // Push value
+ *sval |= *tk++; // & LO LONG (will this work???--should)
+//printf("evexpr(): CONST = %lX\n", *sval);
*++sattr = ABS | DEFINED; // Push simple attribs
break;
case ACONST:
*++sattr = ABS | DEFINED; // Push simple attribs
break;
case ACONST:
void InitExpression(void);
int expr1(void);
int expr2(void);
void InitExpression(void);
int expr1(void);
int expr2(void);
-int expr(TOKEN *, uint32_t *, WORD *, SYM **);
-int evexpr(TOKEN *, uint32_t *, WORD *, SYM **);
+int expr(TOKEN *, uint64_t *, WORD *, SYM **);
+int evexpr(TOKEN *, uint64_t *, WORD *, SYM **);
int siz = (int)size;
// Try to optimize to MOVEQ
int siz = (int)size;
// Try to optimize to MOVEQ
+ // N.B.: We can get away with casting the uint64_t to a 32-bit value
+ // because it checks for a SIZL (i.e., a 32-bit value).
if (CHECK_OPTS(OPT_MOVEL_MOVEQ)
&& (siz == SIZL) && (am0 == IMMED) && (am1 == DREG)
&& ((a0exattr & (TDB | DEFINED)) == DEFINED)
if (CHECK_OPTS(OPT_MOVEL_MOVEQ)
&& (siz == SIZL) && (am0 == IMMED) && (am1 == DREG)
&& ((a0exattr & (TDB | DEFINED)) == DEFINED)
- && (a0exval + 0x80 < 0x100))
+ && ((uint32_t)a0exval + 0x80 < 0x100))
{
m_moveq((WORD)0x7000, (WORD)0);
{
m_moveq((WORD)0x7000, (WORD)0);
return error(rel_error);
//}
return error(rel_error);
//}
- v = a0exval - (sloc + 2);
+ v = (uint32_t)a0exval - (sloc + 2);
// Optimize branch instr. size
if (siz == SIZN)
// Optimize branch instr. size
if (siz == SIZN)
//
int m_movem(WORD inst, WORD siz)
{
//
int m_movem(WORD inst, WORD siz)
{
WORD i;
WORD w;
WORD rmask;
WORD i;
WORD w;
WORD rmask;
//
int HandleRept(void)
{
//
int HandleRept(void)
{
// Evaluate repeat expression
if (abs_expr(&eval) != OK)
// Evaluate repeat expression
if (abs_expr(&eval) != OK)
for(int i=0; i<3; i++)
*p++ = *tok++;
}
for(int i=0; i<3; i++)
*p++ = *tok++;
}
- else if (*tok == CONST)
+ else if (*tok == CONST) // Constants are 64-bits
- *p++ = *tok++;
- *p++ = *tok++;
+ *p++ = *tok++; // Token
+ *p++ = *tok++; // Hi LONG
+ *p++ = *tok++; // Lo LONG
}
else if ((*tok == STRING) || (*tok == SYMBOL))
{
}
else if ((*tok == STRING) || (*tok == SYMBOL))
{
{
//Since index register isn't used here, store register number in this field
AnIXREG = *tok++ & 7; // (Dn)
{
//Since index register isn't used here, store register number in this field
AnIXREG = *tok++ & 7; // (Dn)
if (*tok == ')')
{
tok++;
if (*tok == ')')
{
tok++;
AnEXTEN |= EXT_BS; // Base register suppressed
AnEXTEN |= EXT_BDSIZE0; // Base displacement null
AnEXTEN |= EXT_IISPOSN; // Indirect Postindexed with Null Outer Displacement
AnEXTEN |= EXT_BS; // Base register suppressed
AnEXTEN |= EXT_BDSIZE0; // Base displacement null
AnEXTEN |= EXT_IISPOSN; // Indirect Postindexed with Null Outer Displacement
AnREG = 6 << 3; // stuff 110 to mode field
goto AnOK;
}
else if (*tok == 'L')
{
// TODO: does DINDL gets used at all?
AnREG = 6 << 3; // stuff 110 to mode field
goto AnOK;
}
else if (*tok == 'L')
{
// TODO: does DINDL gets used at all?
AnEXTEN = 1 << 1; // Long index size
tok++;
}
else if (*tok == 'W') // (Dn.w)
{
// TODO: does DINDW gets used at all?
AnEXTEN = 1 << 1; // Long index size
tok++;
}
else if (*tok == 'W') // (Dn.w)
{
// TODO: does DINDW gets used at all?
AnEXTEN = 1 << 1; // Word index size
tok++;
}
AnEXTEN = 1 << 1; // Word index size
tok++;
}
else if (*tok == '[')
{ // ([...
tok++;
else if (*tok == '[')
{ // ([...
tok++;
- AnEXTEN|=EXT_FULLWORD; //Definitely using full extension format, so set bit 8
+ AnEXTEN |= EXT_FULLWORD; // Definitely using full extension format, so set bit 8
+
// Check to see if base displacement is present
// Check to see if base displacement is present
- if (*tok!=CONST && *tok !=SYMBOL)
+ if (*tok != CONST && *tok != SYMBOL)
+ AnEXTEN |= EXT_BDSIZE0;
}
else
{
expr(AnBEXPR, &AnBEXVAL, &AnBEXATTR, &AnESYM);
}
else
{
expr(AnBEXPR, &AnBEXVAL, &AnBEXATTR, &AnESYM);
- if (CHECK_OPTS(OPT_BASE_DISP) && AnBEXVAL==0 && AnEXATTR!=0)
+ if (CHECK_OPTS(OPT_BASE_DISP) && AnBEXVAL == 0 && AnEXATTR != 0)
{
// bd=0 so let's optimise it out
AnEXTEN|=EXT_BDSIZE0;
}
else if (*tok==DOTL)
{ // ([bd.l,...
{
// bd=0 so let's optimise it out
AnEXTEN|=EXT_BDSIZE0;
}
else if (*tok==DOTL)
{ // ([bd.l,...
+ AnEXTEN |= EXT_BDSIZEL;
// Is .W forced here?
if (*tok == DOTW)
{
// Is .W forced here?
if (*tok == DOTW)
{
+ AnEXTEN |= EXT_BDSIZEW;
// to absolute short
if (CHECK_OPTS(OPT_ABS_SHORT)
&& ((AnBEXATTR & (TDB | DEFINED)) == DEFINED)
// to absolute short
if (CHECK_OPTS(OPT_ABS_SHORT)
&& ((AnBEXATTR & (TDB | DEFINED)) == DEFINED)
- && ((AnBEXVAL + 0x8000) < 0x10000))
+ && (((uint32_t)AnBEXVAL + 0x8000) < 0x10000))
{
AnEXTEN |= EXT_BDSIZEW;
warn("absolute value in base displacement ranging $FFFF8000..$00007FFF optimised to absolute short");
{
AnEXTEN |= EXT_BDSIZEW;
warn("absolute value in base displacement ranging $FFFF8000..$00007FFF optimised to absolute short");
}
else if ((*tok >= KW_A0) && (*tok <= KW_A7))
{ // ([bd,An,...
}
else if ((*tok >= KW_A0) && (*tok <= KW_A7))
{ // ([bd,An,...
- AnREG = (6<<3)|*tok & 7;
+ AnREG = (6 << 3) | *tok & 7;
tok++;
}
else if ((*tok >= KW_D0) && (*tok <= KW_D7))
tok++;
}
else if ((*tok >= KW_D0) && (*tok <= KW_D7))
+ // ([bd,An/PC],Xn.W/L...)
+ switch ((int)*tok)
- // ([bd,An/PC],Xn.W/L...)
- switch ((int)*tok)
- {
- // Index reg size: <empty> | .W | .L
- case DOTW:
- tok++;
- break;
- default:
- break;
- case DOTL:
- AnEXTEN |= EXT_L;
- tok++;
- break;
- case DOTB:
- // .B not allowed here...
- goto badmode;
- }
+ // Index reg size: <empty> | .W | .L
+ case DOTW:
+ tok++;
+ break;
+ default:
+ break;
+ case DOTL:
+ AnEXTEN |= EXT_L;
+ tok++;
+ break;
+ case DOTB:
+ // .B not allowed here...
+ goto badmode;
{
if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
return error("scale factor expression must evaluate");
{
if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
return error("scale factor expression must evaluate");
switch (AnEXVAL)
{
case 1:
switch (AnEXVAL)
{
case 1:
return error("comma expected");
else
tok++; // eat the comma
return error("comma expected");
else
tok++; // eat the comma
// ([bd,An/PC],Xn,od)
if (*tok == DOTL)
{
// ([bd,An/PC],Xn,od)
if (*tok == DOTL)
{
// optimized to absolute short
if (CHECK_OPTS(OPT_ABS_SHORT)
&& ((AnEXATTR & (TDB | DEFINED)) == DEFINED)
// optimized to absolute short
if (CHECK_OPTS(OPT_ABS_SHORT)
&& ((AnEXATTR & (TDB | DEFINED)) == DEFINED)
- && ((AnEXVAL + 0x8000) < 0x10000))
+ && (((uint32_t)AnEXVAL + 0x8000) < 0x10000))
{
AnEXTEN |= EXT_IISPOSW; // Word outer displacement
AMn = MEMPOST;
{
AnEXTEN |= EXT_IISPOSW; // Word outer displacement
AMn = MEMPOST;
// Is .W forced here?
if (*tok == DOTW)
// Is .W forced here?
if (*tok == DOTW)
}
// Check for final closing parenthesis
}
// Check for final closing parenthesis
else
return error("Closing parenthesis missing on addressing mode");
else
return error("Closing parenthesis missing on addressing mode");
// Check for od
if (*tok == ')') // ([bd,An/PC],Xn)
// Check for od
if (*tok == ')') // ([bd,An/PC],Xn)
// expr[.W][]
AnEXTEN |= EXT_IISNOIW; // Word outer displacement with IS suppressed
AMn = MEMPRE;
// expr[.W][]
AnEXTEN |= EXT_IISNOIW; // Word outer displacement with IS suppressed
AMn = MEMPRE;
if (*tok == DOTW)
{
//AnEXTEN|=EXT_IISNOIW; // Word outer displacement
AMn = MEMPOST;
tok++;
}
if (*tok == DOTW)
{
//AnEXTEN|=EXT_IISNOIW; // Word outer displacement
AMn = MEMPOST;
tok++;
}
// Defined, absolute values from $FFFF8000..$00007FFF get
// optimized to absolute short
else if (CHECK_OPTS(OPT_BASE_DISP)
&& ((AnEXATTR & (TDB | DEFINED)) == DEFINED)
// Defined, absolute values from $FFFF8000..$00007FFF get
// optimized to absolute short
else if (CHECK_OPTS(OPT_BASE_DISP)
&& ((AnEXATTR & (TDB | DEFINED)) == DEFINED)
- && ((AnEXVAL + 0x8000) < 0x10000))
+ && (((uint32_t)AnEXVAL + 0x8000) < 0x10000))
{
//AnEXTEN|=EXT_IISNOIW; // Word outer displacement with IS suppressed
warn("outer displacement absolute value from $FFFF8000..$00007FFF optimised to absolute short");
{
//AnEXTEN|=EXT_IISNOIW; // Word outer displacement with IS suppressed
warn("outer displacement absolute value from $FFFF8000..$00007FFF optimised to absolute short");
+ // ([bd,An/PC],Xn.W/L...)
+ switch ((int)*tok)
- // ([bd,An/PC],Xn.W/L...)
- switch ((int)*tok)
- {
- // Index reg size: <empty> | .W | .L
- case DOTW:
- tok++;
- break;
- default:
- break;
- case DOTL:
- tok++;
- AnEXTEN |= EXT_L;
- break;
- case DOTB:
- // .B not allowed here...
- goto badmode;
- }
+ // Index reg size: <empty> | .W | .L
+ case DOTW:
+ tok++;
+ break;
+ default:
+ break;
+ case DOTL:
+ tok++;
+ AnEXTEN |= EXT_L;
+ break;
+ case DOTB:
+ // .B not allowed here...
+ goto badmode;
// get optimized to absolute short
if (CHECK_OPTS(OPT_BASE_DISP)
&& ((AnEXATTR & (TDB | DEFINED)) == DEFINED)
// get optimized to absolute short
if (CHECK_OPTS(OPT_BASE_DISP)
&& ((AnEXATTR & (TDB | DEFINED)) == DEFINED)
- && ((AnEXVAL + 0x8000) < 0x10000))
+ && (((uint32_t)AnEXVAL + 0x8000) < 0x10000))
{
expr_size = EXT_IISPREW;
warn("outer displacement absolute value from $FFFF8000..$00007FFF optimised to absolute short");
{
expr_size = EXT_IISPREW;
warn("outer displacement absolute value from $FFFF8000..$00007FFF optimised to absolute short");
// to absolute short
if (CHECK_OPTS(OPT_ABS_SHORT)
&& ((AnEXATTR & (TDB | DEFINED)) == DEFINED)
// to absolute short
if (CHECK_OPTS(OPT_ABS_SHORT)
&& ((AnEXATTR & (TDB | DEFINED)) == DEFINED)
- && ((AnEXVAL + 0x8000) < 0x10000))
+ && (((uint32_t)AnEXVAL + 0x8000) < 0x10000))
char * equate; // Symbol (or NULL)
int labtyp = 0; // Label type (':', DCOLON)
int equtyp = 0; // Equ type ('=', DEQUALS)
char * equate; // Symbol (or NULL)
int labtyp = 0; // Label type (':', DCOLON)
int equtyp = 0; // Equ type ('=', DEQUALS)
- uint32_t eval; // Expression value
+ uint64_t eval; // Expression value
WORD eattr; // Expression attributes
SYM * esym; // External symbol involved in expr.
WORD siz = 0; // Size suffix to mnem/diretve/macro
WORD eattr; // Expression attributes
SYM * esym; // External symbol involved in expr.
WORD siz = 0; // Size suffix to mnem/diretve/macro
if (*tok == EOL)
goto normal;
if (*tok == EOL)
goto normal;
- // Next token MUST be a symbol
+ // First token MUST be a symbol (if we get here, tok didn't advance)
if (*tok++ != SYMBOL)
{
error("syntax error; expected symbol");
if (*tok++ != SYMBOL)
{
error("syntax error; expected symbol");
{
// Advance token pointer to the constant
tok += 3;
{
// Advance token pointer to the constant
tok += 3;
+ tok++; // Skip the hi LONG, so pointing at lo LONG
// Anything other than a 0 or a 1 will result in "No Bank"
if (*tok == 0)
// Anything other than a 0 or a 1 will result in "No Bank"
if (*tok == 0)
//
int GetRegister(WORD rattr)
{
//
int GetRegister(WORD rattr)
{
- uint32_t eval; // Expression value
+ uint64_t eval; // Expression value
WORD eattr; // Expression attributes
SYM * esym; // External symbol involved in expr.
TOKEN r_expr[EXPRSIZE]; // Expression token list
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
WORD attrflg;
int indexed; // Indexed register flag
- uint32_t eval; // Expression value
+ uint64_t eval; // Expression value
WORD eattr; // Expression attributes
SYM * esym; // External symbol involved in expr.
TOKEN r_expr[EXPRSIZE]; // Expression token list
WORD eattr; // Expression attributes
SYM * esym; // External symbol involved in expr.
TOKEN r_expr[EXPRSIZE]; // Expression token list
{
// CC using a constant number
tok++;
{
// CC using a constant number
tok++;
+ tok++; // Toss hi LONG, as most likely not 64-bit number
+ val = *tok; // Use lo LONG
// Count the # of tokens in the expression
for(len=0; fexpr[len]!=ENDEXPR; len++)
{
// Count the # of tokens in the expression
for(len=0; fexpr[len]!=ENDEXPR; len++)
{
- // Add one to len for 2X tokens
- if (fexpr[len] == CONST || fexpr[len] == SYMBOL)
+ // Add one to len for 2X tokens, two for 3X tokens
+ if (fexpr[len] == SYMBOL)
+ else if (fexpr[len] == CONST)
+ len += 2;
int ResolveFixups(int sno)
{
PTR fup; // Current fixup
int ResolveFixups(int sno)
{
PTR fup; // Current fixup
- uint32_t eval; // Expression value
+ uint64_t eval; // Expression value
SYM * sy; // (Temp) pointer to a symbol
uint16_t i; // (Temp) word
int reg2;
SYM * sy; // (Temp) pointer to a symbol
uint16_t i; // (Temp) word
int reg2;
// to choke on legitimate code... Need to investigate this further
// before changing anything else here!
case CONST:
// to choke on legitimate code... Need to investigate this further
// before changing anything else here!
case CONST:
- sprintf(numbuf, "$%lx", (long unsigned int)*tk++);
+ tk++; // Skip the hi LONG...
+ sprintf(numbuf, "$%lx", (uint64_t)*tk++);
d = numbuf;
break;
case DEQUALS:
d = numbuf;
break;
case DEQUALS:
int state = 0; // State for keyword detector
int j = 0; // Var for keyword detector
uint8_t c; // Random char
int state = 0; // State for keyword detector
int j = 0; // Var for keyword detector
uint8_t c; // Random char
- uint32_t v; // Random value
+ uint64_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;
uint8_t * nullspot = NULL; // Spot to clobber for SYMBOL termination
int stuffnull; // 1:terminate SYMBOL '\0' at *nullspot
uint8_t c1;
}
else if ((*(ln + 1) & 0xDF) == 'L')
{
}
else if ((*(ln + 1) & 0xDF) == 'L')
{
ln += 2;
}
}
}
*tk++ = CONST;
ln += 2;
}
}
}
*tk++ = CONST;
+ *tk++ = v >> 32; // High LONG of 64-bit value
+ *tk++ = v & 0xFFFFFFFF; // Low LONG of 64-bit value
if (obj_format == ALCYON)
{
if (obj_format == ALCYON)
{
if ((*(ln + 1) == 'l') || (*(ln + 1) == 'L'))
{
if ((*(ln + 1) == 'l') || (*(ln + 1) == 'L'))
{
ln += 2;
}
}
*tk++ = CONST;
ln += 2;
}
}
*tk++ = CONST;
+ *tk++ = v >> 32; // High LONG of 64-bit value
+ *tk++ = v & 0xFFFFFFFF; // Low LONG of 64-bit value
continue;
case '@': // @ or octal constant
if (*ln < '0' || *ln > '7')
continue;
case '@': // @ or octal constant
if (*ln < '0' || *ln > '7')
if ((*(ln+1) == 'l') || (*(ln+1) == 'L'))
{
if ((*(ln+1) == 'l') || (*(ln+1) == 'L'))
{
ln += 2;
}
}
*tk++ = CONST;
ln += 2;
}
}
*tk++ = CONST;
+ *tk++ = v >> 32; // High LONG of 64-bit value
+ *tk++ = v & 0xFFFFFFFF; // Low LONG of 64-bit value
continue;
case '^': // ^ or ^^ <operator-name>
if (*ln != '^')
continue;
case '^': // ^ or ^^ <operator-name>
if (*ln != '^')
v &= 0x000000FF;
ln += 2;
*tk++ = CONST;
v &= 0x000000FF;
ln += 2;
*tk++ = CONST;
+ *tk++ = 0; // Hi LONG of 64-bits
*tk++ = v;
*tk++ = DOTB;
}
*tk++ = v;
*tk++ = DOTB;
}
v &= 0x0000FFFF;
ln += 2;
*tk++ = CONST;
v &= 0x0000FFFF;
ln += 2;
*tk++ = CONST;
+ *tk++ = 0; // Hi LONG of 64-bits
*tk++ = v;
*tk++ = DOTW;
}
else if ((*(ln + 1) == 'l') || (*(ln + 1) == 'L'))
{
*tk++ = v;
*tk++ = DOTW;
}
else if ((*(ln + 1) == 'l') || (*(ln + 1) == 'L'))
{
+ *tk++ = 0; // Hi LONG of 64-bits
*tk++ = v;
*tk++ = DOTL;
}
*tk++ = v;
*tk++ = DOTL;
}
+ *tk++ = v >> 32; // High LONG of 64-bit value
+ *tk++ = v & 0xFFFFFFFF; // Low LONG of 64-bit value
}
//printf("CONST: %i\n", v);
}
//printf("CONST: %i\n", v);
printf("[COLON]");
else if (*t == CONST)
{
printf("[COLON]");
else if (*t == CONST)
{
- t++;
- printf("[CONST: $%X]", (uint32_t)*t);
+ printf("[CONST: $%lX]", ((uint64_t)t[1] << 32) | (uint64_t)t[2]);
+ t += 2;
}
else if (*t == ACONST)
{
}
else if (*t == ACONST)
{
// Release Information
#define MAJOR 1 // Major version number
// Release Information
#define MAJOR 1 // Major version number
-#define MINOR 8 // Minor version number
-#define PATCH 7 // Patch release number
+#define MINOR 9 // Minor version number
+#define PATCH 0 // Patch release number
projects / rmac / commitdiff