rmac
/
rmac
mirror of http://shamusworld.gotdns.org/git/rmac
1
0
Fork 0
Code Issues 5 Packages Projects Releases Wiki Activity
rmac/parmode.h

1308 lines
29 KiB
C
Raw Permalink Blame History

//
// RMAC - Renamed Macro Assembler for all Atari computers
// PARMODE.C - Addressing Modes Parser Include
// Copyright (C) 199x Landon Dyer, 2011-2021 Reboot and Friends
// RMAC derived from MADMAC v1.07 Written by Landon Dyer, 1986
// Source utilised with the kind permission of Landon Dyer
//
// This file is included (twice) to parse two addressing modes, into slightly
// different var names
{
uint64_t scaleval; // Expression's value
TOKEN scaleexpr[EXPRSIZE]; // Expression
WORD scaleattr; // Expression's attribute
SYM * scaleesym; // External symbol involved in expr
// Dn
// An
// # expression
if ((*tok >= REG68_D0) && (*tok <= REG68_D7))
{
AMn = DREG;
AnREG = *tok++ & 7;
}
else if ((*tok >= REG68_A0) && (*tok <= REG68_A7))
{
AMn = AREG;
AnREG = *tok++ & 7;
}
else if (*tok == '#')
{
tok++;
if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
return ERROR;
AMn = IMMED;
}
// (An)
// (An)+
// (An,Xn[.siz][*scale])
// (PC,Xn[.siz][*scale])
// (d16,An)
// (d8,An,Xn[.siz][*scale])
// (d16,PC)
// (d8,PC,Xn[.siz][*scale])
// ([bd,An],Xn[.siz][*scale],od)
// ([bd,An,Xn[.siz][*scale]],od)
// ([bd,PC],Xn[.siz][*scale],od)
// ([bd,PC,Xn[.siz][*scale]],od)
else if (*tok == '(')
{
int ea_PC = 0; // Flag that let us know if we have PC or An relative ea
tok++;
if ((*tok >= REG68_A0) && (*tok <= REG68_A7))
{
AnREG = *tok++ & 7;
if (*tok == ')')
{
tok++;
if (*tok == '+')
{
tok++;
AMn = APOSTINC;
}
else
AMn = AIND;
goto AnOK;
}
AMn = AINDEXED;
goto AMn_IX0; // Handle ",Xn[.siz][*scale])"
}
else if ((*tok >= REG68_D0) && (*tok <= REG68_D7))
{
// Since index register isn't used here, store register number in this field
AnIXREG = *tok++ & 7; // (Dn)
if (*tok == ')')
{
tok++;
AnEXTEN |= EXT_FULLWORD; // Definitely using full extension format, so set bit 8
AnEXTEN |= EXT_BS; // Base register suppressed
AnEXTEN |= EXT_BDSIZE0; // Base displacement null
AnEXTEN |= EXT_IISPOSN; // Indirect Postindexed with Null Outer Displacement
AMn = MEMPOST;
AnREG = 6 << 3; // stuff 110 to mode field
goto AnOK;
}
else if (*tok == 'L')
{
AMn = DINDL; // (Dn.l)
AnEXTEN = 1 << 11; // Long index size
tok++;
}
else if (*tok == 'W') // (Dn.w)
{
AMn = DINDW;
AnEXTEN = 0 << 11; // Word index size
tok++;
}
else if (*tok == ',')
{
// ([bd,An],Xn..) without bd, An
// Base displacement is suppressed
AnEXTEN |= EXT_FULLWORD; // Definitely using full extension format, so set bit 8
AnEXTEN |= EXT_BS; // Base register suppressed
AnEXTEN |= EXT_BDSIZE0;
AnREG = 6 << 3; // stuff 110 to mode field
tok++;
goto CHECKODn;
}
else
{
return error("(Dn) error");
}
if (*tok == '*')
{ // scale: *1, *2, *4, *8
tok++;
if (*tok == SYMBOL)
{
if (expr(scaleexpr, &scaleval, &scaleattr, &scaleesym) != OK)
return error("scale factor expression must evaluate");
switch (scaleval)
{
case 1:
break;
case 2:
AnIXSIZ |= TIMES2;
AnEXTEN |= 1 << 9;
break;
case 4:
AnIXSIZ |= TIMES4;
AnEXTEN |= 2 << 9;
break;
case 8:
AnIXSIZ |= TIMES8;
AnEXTEN |= 3 << 9;
break;
default:
goto badmode;
}
}
else if (*tok++ != CONST)
goto badmode;
else
{
switch ((int)*tok++)
{
case 1:
break;
case 2:
AnIXSIZ |= TIMES2;
AnEXTEN |= 1 << 9;
break;
case 4:
AnIXSIZ |= TIMES4;
AnEXTEN |= 2 << 9;
break;
case 8:
AnIXSIZ |= TIMES8;
AnEXTEN |= 3 << 9;
break;
default:
goto badmode;
}
tok++; // Take into account that constants are 64-bit
}
}
if (*tok == ')')
{
tok++;
AnEXTEN |= EXT_FULLWORD; // Definitely using full extension format, so set bit 8
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
AMn = MEMPOST;
goto AnOK;
}
else if (*tok == ',')
{
tok++; // eat the comma
// It might be (Dn[.wl][*scale],od)
// Maybe this is wrong and we have to write some code here
// instead of reusing that path...
AnEXTEN |= EXT_FULLWORD; // Definitely using full extension format, so set bit 8
AnEXTEN |= EXT_BS; // Base displacement null - suppressed
AnEXTEN |= AnIXREG << 12;
goto CHECKODn;
}
else
return error("unhandled so far");
}
else if (*tok == REG68_PC)
{ // (PC,Xn[.siz][*scale])
tok++;
AMn = PCINDEXED;
// Common index handler; enter here with 'tok' pointing at the
// comma.
AMn_IX0: // Handle indexed with missing expr
AnEXVAL = 0;
AnEXATTR = ABS | DEFINED;
AMn_IXN: // Handle any indexed (tok -> a comma)
if (*tok++ != ',')
goto badmode;
if (*tok < REG68_D0 || *tok > REG68_A7)
goto badmode;
AnIXREG = *tok++ & 15;
switch ((int)*tok)
{ // Index reg size: <empty> | .W | .L
case DOTW:
tok++;
default:
AnIXSIZ = 0;
break;
case DOTL:
AnIXSIZ = 0x0800;
tok++;
break;
case DOTB: // .B not allowed here...
goto badmode;
}
if (*tok == '*')
{ // scale: *1, *2, *4, *8
tok++;
if (*tok == SYMBOL)
{
if (expr(scaleexpr, &scaleval, &scaleattr, &scaleesym) != OK)
return error("scale factor expression must evaluate");
switch (scaleval)
{
case 1:
break;
case 2:
AnIXSIZ |= TIMES2;
break;
case 4:
AnIXSIZ |= TIMES4;
break;
case 8:
AnIXSIZ |= TIMES8;
break;
default:
goto badmode;
}
}
else if (*tok++ != CONST)
goto badmode;
else
{
switch ((int)*tok++)
{
case 1:
break;
case 2:
AnIXSIZ |= TIMES2;
break;
case 4:
AnIXSIZ |= TIMES4;
break;
case 8:
AnIXSIZ |= TIMES8;
break;
default:
goto badmode;
}
tok++; // Take into account that constants are 64-bit
}
}
if (*tok == ',')
{
// If we got here we didn't get any [] stuff
// so let's suppress base displacement before
// branching off
tok++;
AnEXTEN |= EXT_BDSIZE0; // Base displacement null - suppressed
goto CHECKODn;
}
if (*tok++ != ')') // final ")"
goto badmode;
goto AnOK;
}
else if (*tok == '[')
{ // ([...
tok++;
AnEXTEN |= EXT_FULLWORD; // Definitely using full extension format, so set bit 8
// Check to see if base displacement is present
if (*tok != CONST && *tok != SYMBOL)
{
AnEXTEN |= EXT_BDSIZE0;
}
else
{
expr(AnBEXPR, &AnBEXVAL, &AnBEXATTR, &AnESYM);
if (CHECK_OPTS(OPT_020_DISP) && (AnBEXVAL == 0) && (AnEXATTR != 0))
{
// bd = 0 so let's optimise it out
AnEXTEN |= EXT_BDSIZE0;
}
else if (*tok == DOTL)
{
// ([bd.l,...
AnEXTEN |= EXT_BDSIZEL;
tok++;
}
else
{
// ([bd[.w],... or ([bd,...
// Is .W forced here?
if (*tok == DOTW)
{
AnEXTEN |= EXT_BDSIZEW;
tok++;
}
else
{
// Defined, absolute values from $FFFF8000..$00007FFF
// get optimized to absolute short
if (CHECK_OPTS(OPT_020_DISP)
&& ((AnBEXATTR & (TDB | DEFINED)) == DEFINED)
&& (((uint32_t)AnBEXVAL + 0x8000) < 0x10000))
{
AnEXTEN |= EXT_BDSIZEW;
if (optim_warn_flag)
warn("o5: absolute value in base displacement ranging $FFFF8000..$00007FFF optimised to absolute short");
}
else
{
AnEXTEN |= EXT_BDSIZEL;
}
}
}
if (*tok == ',')
tok++;
}
// Check for address register or PC, suppress base register
// otherwise
if (*tok == REG68_PC)
{ // ([bd,PC,...
ea_PC = 3; // Set flag in order to set proper value to AMn below when we can make a decision on ea
// (why "3"? Well, MEMPOST is 3 away from PCMPOST, etc. Have a look at amode.h)
AnREG = (7 << 3) | 3; // PC is special case - stuff 011 to register field and 111 to the mode field
tok++;
}
else if ((*tok >= REG68_A0) && (*tok <= REG68_A7))
{ // ([bd,An,...
AnREG = (6 << 3) | (*tok & 7);
tok++;
}
else if ((*tok >= REG68_D0) && (*tok <= REG68_D7))
{
// ([bd,Dn,...
AnREG = (6 << 3);
AnEXTEN |= ((*tok & 7) << 12);
AnEXTEN |= EXT_D;
AnEXTEN |= EXT_BS; // Oh look, a data register! Which means that base register is suppressed
tok++;
// Check for size
// ([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;
}
// Check for scale
if (*tok == '*') // ([bd,An/PC],Xn*...)
{ // scale: *1, *2, *4, *8
tok++;
if (*tok == SYMBOL)
{
if (expr(scaleexpr, &scaleval, &scaleattr, &scaleesym) != OK)
return error("scale factor expression must evaluate");
switch (scaleval)
{
case 1:
break;
case 2:
AnIXSIZ |= TIMES2;
break;
case 4:
AnIXSIZ |= TIMES4;
break;
case 8:
AnIXSIZ |= TIMES8;
break;
default:
goto badmode;
}
}
else if (*tok++ != CONST)
goto badmode;
else
{
switch ((int)*tok++)
{
case 1:
break;
case 2:
AnIXSIZ |= TIMES2;
break;
case 4:
AnIXSIZ |= TIMES4;
break;
case 8:
AnIXSIZ |= TIMES8;
break;
default:
goto badmode;
}
tok++; // Take into account that constants are 64-bit
}
}
if (*tok == ']') // ([bd,Dn]...
{
tok++;
goto IS_SUPPRESSEDn;
}
}
else if (*tok == ']')
{
// PC and Xn is suppressed
AnREG = 6 << 3; // stuff 110b to mode field
AnEXTEN |= EXT_BS;
}
else
{
goto badmode;
}
// At a crossroads here. We can accept either ([bd,An/PC],... or ([bd,An/PC,Xn*scale],...
if (*tok == ']')
{
// ([bd,An/PC],Xn,od)
// Check for Xn
tok++;
if (*tok == ')')
{
// Xn and od are non existent, get out of jail free card
tok++;
AMn = MEMPRE + ea_PC; // ([bc,An,Xn],od) with no Xn and od
AnEXTEN |= EXT_IS | EXT_IISPREN; // Suppress Xn and od
goto AnOK;
}
else if (*tok != ',')
return error("comma expected after ]");
else
tok++; // eat the comma
if ((*tok >= REG68_A0) && (*tok <= REG68_A7))
{
AnIXREG = ((*tok & 7) << 12);
AnEXTEN |= EXT_A;
tok++;
}
else if ((*tok >= REG68_D0) && (*tok <= REG68_D7))
{
AnEXTEN |= ((*tok & 7) << 12);
AnEXTEN |= EXT_D;
tok++;
}
else
{
// No index found, suppress it
AnEXTEN |= EXT_IS;
tok--; // Rewind tok to point to the comma
goto IS_SUPPRESSEDn; // https://xkcd.com/292/ - what does he know anyway?
}
// Check for Xn size
// ([bd,An/PC],Xn.W/L...)
switch ((int)*tok)
{
// Index reg size: <empty> | .W | .L
case DOTW:
tok++;
break;
case DOTL:
AnEXTEN |= EXT_L;
tok++;
break;
case DOTB:
// .B not allowed here...
goto badmode;
default:
break;
}
// Check for Xn scale
if (*tok == '*') // ([bd,An/PC],Xn*...)
{ // scale: *1, *2, *4, *8
tok++;
if (*tok == SYMBOL)
{
if (expr(scaleexpr, &scaleval, &scaleattr, &scaleesym) != OK)
return error("scale factor expression must evaluate");
}
else if (*tok == CONST)
{
scaleval = (int)*tok++;
tok++; // Take into account that constants are 64-bit
}
else
goto badmode;
switch (scaleval)
{
case 1:
break;
case 2:
AnIXSIZ |= TIMES2;
break;
case 4:
AnIXSIZ |= TIMES4;
break;
case 8:
AnIXSIZ |= TIMES8;
break;
default:
goto badmode;
}
}
// Check for od
if (*tok == ')') // ([bd,An/PC],Xn)
{
// od is non existent, get out of jail free card
AMn = MEMPOST + ea_PC; // let's say it's ([bd,An],Xn,od) with od=0 then
AnEXTEN |= EXT_IISPOSN; // No outer displacement
tok++;
goto AnOK;
}
else if (*tok != ',')
return error("comma expected");
else
tok++; // eat the comma
CHECKODn:
if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
goto badmode;
if (CHECK_OPTS(OPT_020_DISP) && (AnEXATTR & DEFINED) && (AnEXVAL == 0))
{
// od = 0 so optimise it out
AMn = MEMPOST + ea_PC; // let's say it's ([bd,An],Xn,od) with od=0 then
AnEXTEN |= EXT_IISPOSN; // No outer displacement
tok++;
goto AnOK;
}
// ([bd,An/PC],Xn,od)
// Is .W forced here?
if (*tok == DOTW)
{
tok++;
// od[.W]
AnEXTEN |= EXT_IISPOSW; // Word outer displacement
AMn = MEMPOST + ea_PC;
}
else
{
// Is .L forced here?
if (*tok == DOTL)
tok++; // Doesn't matter, we're going for .L anyway
WORD od_ea = 0;
// od.L
if (!(AnEXTEN & EXT_BS))
od_ea = EXT_IISPOSL; // Long outer displacement
else
{
// bd is suppressed, so sticking the od size in bd
od_ea = EXT_BDSIZEL;
// And of course the expression has to be copied to
// AnBEXPR instead of AnEXPR. Yay. :-/
int i = 0;
do
{
AnBEXPR[i] = AnEXPR[i];
i++;
}
while (AnEXPR[i] != 'E');
AnBEXPR[i] = 'E';
}
AMn = MEMPOST + ea_PC;
// Defined, absolute values from $FFFF8000..$00007FFF get
// optimized to absolute short
if (CHECK_OPTS(OPT_020_DISP)
&& ((AnEXATTR & (TDB | DEFINED)) == DEFINED)
&& (((uint32_t)AnEXVAL + 0x8000) < 0x10000))
{
od_ea = EXT_IISPOSW; // Word outer displacement
AMn = MEMPOST + ea_PC;
if (optim_warn_flag)
warn("o5: absolute value in outer displacement ranging $FFFF8000..$00007FFF optimised to absolute short");
}
AnEXTEN |= od_ea;
}
// Check for final closing parenthesis
if (*tok == ')')
{
tok++;
goto AnOK;
}
else
return error("Closing parenthesis missing on addressing mode");
IS_SUPPRESSEDn:
// Check for od
if (*tok == ')') // ([bd,An/PC],Xn)
{
// od is non existent, get out of jail free card
AMn = MEMPOST + ea_PC; // let's say it's ([bd,An],Xn,od) with od=0 then
AnEXTEN |= EXT_IISNOIN; // No outer displacement
tok++;
goto AnOK;
}
else if (*tok!=',')
return error("comma expected");
else
tok++; // eat the comma
if ((*tok != CONST) && (*tok != SYMBOL))
goto badmode;
expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM);
if (CHECK_OPTS(OPT_020_DISP) && (AnEXVAL == 0))
{
// od=0 so optimise it out
AMn = MEMPOST + ea_PC; // let's say it's ([bd,An],Xn,od) with od=0 then
AnEXTEN |= EXT_IISNOIN; // No outer displacement
tok++;
goto AnOK;
}
// ([bd,An/PC],Xn,od)
if (*tok == DOTL)
{
// expr.L
tok++;
AMn = MEMPOST + ea_PC;
AnEXTEN |= EXT_IISNOIL; // Long outer displacement with IS suppressed
}
else
{
// expr[.W][]
AnEXTEN |= EXT_IISNOIW; // Word outer displacement with IS suppressed
AMn = MEMPRE + ea_PC;;
if (*tok == DOTW)
{
//AnEXTEN|=EXT_IISNOIW; // Word outer displacement
AMn = MEMPOST + ea_PC;
tok++;
}
// Defined, absolute values from $FFFF8000..$00007FFF get
// optimized to absolute short
else if (CHECK_OPTS(OPT_020_DISP)
&& ((AnEXATTR & (TDB | DEFINED)) == DEFINED)
&& (((uint32_t)AnEXVAL + 0x8000) < 0x10000))
{
//AnEXTEN|=EXT_IISNOIW; // Word outer displacement with IS suppressed
if (optim_warn_flag)
warn("o5: outer displacement absolute value from $FFFF8000..$00007FFF optimised to absolute short");
}
}
// Check for final closing parenthesis
if (*tok == ')')
{
tok++;
goto AnOK;
}
else
return error("Closing parenthesis missing on addressing mode");
}
else if (*tok == ',')
{
tok++; // ([bd,An,Xn.size*scale],od)
// Check for Xn
if ((*tok >= REG68_A0) && (*tok <= REG68_A7))
{
AnEXTEN |= ((*tok & 7) << 12);
AnEXTEN |= EXT_A;
tok++;
}
else if ((*tok >= REG68_D0) && (*tok <= REG68_D7))
{
AnEXTEN |= ((*tok & 7) << 12);
AnEXTEN |= EXT_D;
tok++;
}
// Check for size
// ([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;
}
// Check for scale
if (*tok == '*') // ([bd,An/PC],Xn*...)
{ // scale: *1, *2, *4, *8
tok++;
if (*tok == SYMBOL)
{
if (expr(scaleexpr, &scaleval, &scaleattr, &scaleesym) != OK)
return error("scale factor expression must evaluate");
switch (scaleval)
{
case 1:
break;
case 2:
AnIXSIZ |= TIMES2;
break;
case 4:
AnIXSIZ |= TIMES4;
break;
case 8:
AnIXSIZ |= TIMES8;
break;
default:
goto badmode;
}
}
else if (*tok++ != CONST)
goto badmode;
else
{
switch ((int)*tok++)
{
case 1:
break;
case 2:
AnIXSIZ |= TIMES2;
AnEXTEN |= 1 << 9;
break;
case 4:
AnIXSIZ |= TIMES4;
AnEXTEN |= 2 << 9;
break;
case 8:
AnIXSIZ |= TIMES8;
AnEXTEN |= 3 << 9;
break;
default:
goto badmode;
}
tok++; // Take into account that constants are 64-bit
}
}
// Check for ]
if (*tok != ']')
return error("Expected closing bracket ]");
tok++; // Eat the bracket
// Check for od
if (*tok == ')') // ([bd,An/PC,Xn]...
{
// od is non existent, get out of jail free card
AMn = MEMPRE + ea_PC; // let's say it's ([bd,An,Xn],od) with od suppressed then
AnEXTEN |= EXT_IISPREN; // No outer displacement
tok++;
goto AnOK;
}
else if (*tok++ != ',')
return error("comma expected after ]");
if (*tok == SYMBOL || *tok == CONST)
{
if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
goto badmode;
if (CHECK_OPTS(OPT_020_DISP) && (AnEXVAL == 0) && (AnEXATTR & DEFINED))
{
// od=0 so optimise it out
AMn = MEMPRE + ea_PC; // let's say it's ([bd,An],Xn,od) with od=0 then
AnEXTEN |= EXT_IISPRE0; // No outer displacement
tok++;
goto AnOK;
}
}
// ([bd,An/PC,Xn],od)
if (*tok == DOTL)
{
// expr.L
AMn = MEMPRE + ea_PC;
tok++;
AnEXTEN |= EXT_IISPREL;
}
else
{
// expr.[W]
AMn = MEMPRE + ea_PC;
int expr_size = EXT_IISPREW; // Assume we have a .w value
if ((AnEXVAL + 0x8000) > 0x10000)
{
// Long value, so mark it as such for now
expr_size = EXT_IISPREL;
// Defined, absolute values from $FFFF8000..$00007FFF
// get optimized to absolute short
if (CHECK_OPTS(OPT_020_DISP)
&& ((AnEXATTR & (TDB | DEFINED)) == DEFINED)
&& (((uint32_t)AnEXVAL + 0x8000) < 0x10000))
{
expr_size = EXT_IISPREW;
if (optim_warn_flag)
warn("o5: outer displacement absolute value from $FFFF8000..$00007FFF optimised to absolute short");
}
}
AnEXTEN |= expr_size; // Assume we have a .w value
// Is .W forced here?
if (*tok == DOTW)
{
tok++;
if (expr_size == EXT_IISPREL)
return error("outer displacement value does not fit in .w size");
}
}
// Check for final closing parenthesis
if (*tok == ')')
{
tok++;
goto AnOK;
}
else
return error("Closing parenthesis missing on addressing mode");
}
else
goto badmode;
}
else
{
// (expr...
// We have an aliasing problem here, because a couple of differenct cases end up here:
// (a0), 0(a0,d0), (-288,a0,d0.l) can be easily detected and parsed.
// But what about (160*150)+4(A1)? With the old scheme, i.e. skip past the left parenthesis and try to parse the inside
// tokens will only parse (160*150) and everything else is assumed that it's part of the ea, i.e. +4(a1). This would produce
// an error since the parser would expect (a1). The way to work around this used to be to wrap all the displacement in
// parenthesis, ((160*150)+4)(a1). But that's something the user really doesn't want to think about.
// What we can do is to peek ahead in the token stream and see if we have something that reminds of an expression
// (i.e. no register tokens or commas) until we hit an open parenthesis plus a register (parenthesis balance during the scan
// has to be maintained of course, otherwise we might be led into false conclusions).
TOKEN *look_ahead = tok;
int parenthesis_level = 1; // We count the opening parenthesis so we're not at level 0
int this_is_an_expression = 0;
while (1)
{
if (*look_ahead == EOL)
{
// Something really bad happened, abort
return error("reached end of line while parsing expression");
}
if (*look_ahead == '(')
{
if (parenthesis_level == 0)
{
if (look_ahead[1] == EOL)
{
return error("reached end of line while parsing expression");
}
if ((look_ahead[1] >= REG68_A0 && look_ahead[1] <= REG68_A7) || look_ahead[1] == REG68_PC)
{
tok--; // Rewind token pointer to start of parenthesis
this_is_an_expression = 1;
break;
}
}
parenthesis_level++;
look_ahead++;
continue;
}
if (*look_ahead == ',' || (*look_ahead >= REG68_A0 && *look_ahead <= REG68_A7))
{
// Nope, this is a different case, abort
break;
}
if (*look_ahead == ')')
{
parenthesis_level--;
if (parenthesis_level < 0) return error("unbalanced parenthesis in expression");
look_ahead++;
continue;
}
if (*look_ahead == ACONST||*look_ahead==FCONST)
{
look_ahead += 3; // Skip all the data associated with ACONST
continue;
}
look_ahead++;
}
if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
return ERROR;
// It could be that this is really just an expression prefixing a
// register as a displacement...
if (*tok == '(')
{
goto CHK_FOR_DISPn;
}
// Otherwise, check for PC & etc displacements...
if (*tok++ != ',')
goto badmode;
if ((*tok >= REG68_A0) && (*tok <= REG68_A7))
{
AnREG = *tok & 7;
tok++;
if (*tok == ',')
{
// Check if we're actually doing d8(An,Dn) or
// (d16,An,Dn[.size][*scale])
// TODO: not a very clear cut case from what I can think.
// The only way to distinguish between the two is to check
// AnEXVAL and see if it's >127 or <-128. But this doesn't
// work if AnEXVAL isn't defined yet. For now we fall
// through to d8(An,Dn) but this might bite us in the arse
// during fixups...
if ((AnEXATTR & DEFINED) && (AnEXVAL + 0x80 > 0x100))
{
// We're going to treat it as a full extension format
// with no indirect access and no base displacement/
// index register suppression
AnEXTEN |= EXT_FULLWORD; // Definitely using full extension format, so set bit 8
AnEXTEN |= EXT_IISPRE0; // No Memory Indirect Action
AnEXTEN |= EXT_BDSIZEL; // Base Displacement Size Long
tok++; // Get past the comma
// Our expression is techically a base displacement,
// so let's copy it to the relevant variables so
// eagen0.c can pick it up properly
AnBEXVAL = AnEXVAL;
AnBEXATTR = AnEXATTR;
if ((*tok >= REG68_D0) && (*tok <= REG68_D7))
{
AnEXTEN |= ((*tok++) & 7) << 12;
// Check for size
{
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;
}
}
// Check for scale
if (*tok == '*') // (d16,An,Dn[.size][*scale])
{ // scale: *1, *2, *4, *8
tok++;
if (*tok == SYMBOL)
{
if (expr(scaleexpr, &scaleval, &scaleattr, &scaleesym) != OK)
return error("scale factor expression must evaluate");
switch (scaleval)
{
case 1:
break;
case 2:
AnIXSIZ |= TIMES2;
break;
case 4:
AnIXSIZ |= TIMES4;
break;
case 8:
AnIXSIZ |= TIMES8;
break;
default:
goto badmode;
}
}
else if (*tok++ != CONST)
goto badmode;
else
{
switch ((int)*tok++)
{
case 1:
break;
case 2:
AnIXSIZ |= TIMES2;
break;
case 4:
AnIXSIZ |= TIMES4;
break;
case 8:
AnIXSIZ |= TIMES8;
break;
default:
goto badmode;
}
tok++; // Take into account that constants are 64-bit
}
}
if (*tok++ != ')')
return error("Closing parenthesis missing on addressing mode");
// Let's say that this is the closest to our case
AMn = MEMPOST;
goto AnOK;
}
else
goto badmode;
}
AMn = AINDEXED;
goto AMn_IXN;
}
else if (*tok == ')')
{
AMn = ADISP;
tok++;
goto AnOK;
}
else
goto badmode;
}
else if (*tok == REG68_PC)
{
if (*++tok == ',')
{ // expr(PC,Xn...)
AMn = PCINDEXED;
goto AMn_IXN;
}
else if (*tok == ')')
{
AMn = PCDISP; // expr(PC)
tok++;
goto AnOK;
}
else
goto badmode;
}
else
goto badmode;
}
}
else if (*tok == '-' && tok[1] == '(' && ((tok[2] >= REG68_A0) && (tok[2] <= REG68_A7)) && tok[3] == ')')
{
AMn = APREDEC;
AnREG = tok[2] & 7;
tok += 4;
}
else if (*tok == REG68_CCR)
{
AMn = AM_CCR;
tok++;
goto AnOK;
}
else if (*tok == REG68_SR)
{
AMn = AM_SR;
tok++;
goto AnOK;
}
else if (*tok == REG68_USP)
{
AMn = AM_USP;
tok++;
AnREG = 2; // Added this for the case of USP used in movec (see CREGlut in mach.c). Hopefully nothing gets broken!
goto AnOK;
}
else if ((*tok >= REG68_IC40) && (*tok <= REG68_BC40))
{
AMn = CACHES;
AnREG = *tok++ - REG68_IC40;
// After a cache keyword only a comma or EOL is allowed
if ((*tok != ',') && (*tok != EOL))
return ERROR;
goto AnOK;
}
else if ((*tok >= REG68_SFC) && (*tok <= REG68_CRP))
{
AMn = CREG;
AnREG = (*tok++) - REG68_SFC;
goto AnOK;
}
else if ((*tok >= REG68_FP0) && (*tok <= REG68_FP7))
{
AMn = FREG;
AnREG = (*tok++ & 7);
}
else if ((*tok >= REG68_FPIAR) && (*tok <= REG68_FPCR))
{
AMn = FPSCR;
AnREG = (1 << ((*tok++) - REG68_FPIAR + 10));
}
// expr
// expr.w
// expr.l
// d16(An)
// d8(An,Xn[.siz])
// d16(PC)
// d8(PC,Xn[.siz])
else
{
if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
return ERROR;
CHK_FOR_DISPn:
if (*tok == DOTW)
{
// expr.W
tok++;
AMn = ABSW;
if (((AnEXATTR & (TDB | DEFINED)) == DEFINED) && (AnEXVAL < 0x10000))
AnEXVAL = (int32_t)(int16_t)AnEXVAL; // Sign extend value
goto AnOK;
}
else if (*tok != '(')
{
// expr[.L]
AMn = ABSL;
// .L is forced here
if (*tok == DOTL)
{
// When PC relative is enforced, check for any symbols that aren't
// EQU'd, in this case it's an illegal mode
if ((CHECK_OPTS(OPT_PC_RELATIVE)) && ((AnEXATTR & (DEFINED | REFERENCED | EQUATED)) == (DEFINED | REFERENCED)))
return error("relocation not allowed when o30 is enabled");
tok++;
}
else
{
// Defined, absolute values from $FFFF8000..$00007FFF get
// optimized to absolute short
if (CHECK_OPTS(OPT_ABS_SHORT)
&& ((AnEXATTR & (TDB | DEFINED)) == DEFINED)
&& (((uint32_t)AnEXVAL + 0x8000) < 0x10000))
{
AMn = ABSW;
if (optim_warn_flag)
warn("o0: absolute value from $FFFF8000..$00007FFF optimised to absolute short");
}
}
goto AnOK;
}
tok++;
if ((*tok >= REG68_A0) && (*tok <= REG68_A7))
{
AnREG = *tok++ & 7;
if (*tok == ')')
{
AMn = ADISP;
tok++;
goto AnOK;
}
AMn = AINDEXED;
goto AMn_IXN;
}
else if (*tok == REG68_PC)
{
if (*++tok == ')')
{
AMn = PCDISP;
tok++;
goto AnOK;
}
AMn = PCINDEXED;
goto AMn_IXN;
}
goto badmode;
}
// Addressing mode OK
AnOK:
;
}
// Clean up dirty little macros
#undef AnOK
#undef AMn
#undef AnREG
#undef AnIXREG
#undef AnIXSIZ
#undef AnEXPR
#undef AnEXVAL
#undef AnEXATTR
#undef AnOEXPR
#undef AnOEXVAL
#undef AnOEXATTR
#undef AnESYM
#undef AMn_IX0
#undef AMn_IXN
#undef CHK_FOR_DISPn
#undef AnBEXPR
#undef AnBEXVAL
#undef AnBEXATTR
#undef AnBZISE
#undef AnEXTEN
#undef AMn_030
#undef IS_SUPPRESSEDn
#undef CHECKODn
Reference in New Issue View Git Blame Copy Permalink