// 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
// (d8,An,Xn[.siz][*scale])
// (d16,PC)
// (d8,PC,Xn[.siz][*scale])
- // ([bd,An],Xn,od)
- // ([bd,An,Xn],od)
- // ([bd,PC],Xn,od)
- // ([bd,PC,Xn],od)
+ // ([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 == '(')
{
tok++;
}
else if (*tok == 'L')
{
- // TODO: does DINDL gets used at all?
- AMn = DINDL; // (Dn.l)
- AnEXTEN = 1 << 1; // Long index size
+ AMn = DINDL; // (Dn.l)
+ AnEXTEN = 1 << 11; // Long index size
tok++;
}
else if (*tok == 'W') // (Dn.w)
{
- // TODO: does DINDW gets used at all?
AMn = DINDW;
- AnEXTEN = 1 << 1; // Word index size
+ AnEXTEN = 0 << 11; // Word index size
tok++;
}
else if (*tok == ',')
if (*tok == SYMBOL)
{
- if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
+ if (expr(scaleexpr, &scaleval, &scaleattr, &scaleesym) != OK)
return error("scale factor expression must evaluate");
- switch (AnEXVAL)
+ 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 || *tok > 8)
+ else if (*tok++ != CONST)
goto badmode;
else
{
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
}
}
AMn = MEMPOST;
goto AnOK;
}
- else if (*tok==',')
+ 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_BDSIZE0; // Base displacement null - suppressed
goto CHECKODn;
}
else
if (*tok == SYMBOL)
{
- if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
+ if (expr(scaleexpr, &scaleval, &scaleattr, &scaleesym) != OK)
return error("scale factor expression must evaluate");
- switch (AnEXVAL)
+ switch (scaleval)
{
case 1:
break;
goto badmode;
}
}
- else if (*tok++ != CONST || *tok > 8)
+ else if (*tok++ != CONST)
goto badmode;
else
{
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 ")"
// bd=0 so let's optimise it out
AnEXTEN|=EXT_BDSIZE0;
}
- else if (*tok==DOTL)
+ else if (*tok == DOTL)
{ // ([bd.l,...
AnEXTEN |= EXT_BDSIZEL;
tok++;
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;
+ // ([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 == SYMBOL)
{
- if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
+ if (expr(scaleexpr, &scaleval, &scaleattr, &scaleesym) != OK)
return error("scale factor expression must evaluate");
- switch (AnEXVAL)
+ switch (scaleval)
{
case 1:
break;
goto badmode;
}
}
- else if (*tok++ != CONST || *tok > 8)
+ else if (*tok++ != CONST)
goto badmode;
else
{
default:
goto badmode;
}
+
+ tok++; // Take into account that constants are 64-bit
}
}
if (*tok == ']') // ([bd,Dn]...
if (*tok == SYMBOL)
{
- if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
+ if (expr(scaleexpr, &scaleval, &scaleattr, &scaleesym) != OK)
return error("scale factor expression must evaluate");
- switch (AnEXVAL)
+ switch (scaleval)
{
case 1:
break;
goto badmode;
}
}
- else if (*tok++ != CONST || *tok > 8)
+ else if (*tok++ != CONST)
goto badmode;
else
{
default:
goto badmode;
}
+
+ tok++; // Take into account that constants are 64-bit
}
}
// Check for od
if (*tok == ')') // ([bd,An/PC],Xn)
{
- //od is non existant, get out of jail free card
+ // od is non existent, get out of jail free card
AMn = MEMPOST; // let's say it's ([bd,An],Xn,od) with od=0 then
AnEXTEN |= EXT_IISPOSN; // No outer displacement
tok++;
// Is .W forced here?
if (*tok == DOTW)
+ {
tok++;
+ }
}
// Check for final closing parenthesis
// Check for od
if (*tok == ')') // ([bd,An/PC],Xn)
{
- //od is non existant, get out of jail free card
+ // od is non existent, get out of jail free card
AMn = MEMPOST; // let's say it's ([bd,An],Xn,od) with od=0 then
AnEXTEN |= EXT_IISNOIN; // No outer displacement
tok++;
else
tok++; // eat the comma
- if ((*tok != CONST) && (*tok != SYMBOL))
+ if ((*tok != CONST) && (*tok != SYMBOL))
goto badmode;
expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM);
}
// 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:
+ {
+ // 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 == SYMBOL)
{
- if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK)
+ if (expr(scaleexpr, &scaleval, &scaleattr, &scaleesym) != OK)
return error("scale factor expression must evaluate");
- switch (AnEXVAL)
+ switch (scaleval)
{
case 1:
break;
goto badmode;
}
}
- else if (*tok++ != CONST || *tok > 8)
+ else if (*tok++ != CONST)
goto badmode;
else
{
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 ]
+ // Check for ]
if (*tok != ']')
return error("Expected closing bracket ]");
tok++; // Eat the bracket
- //Check for od
+ // Check for od
if (*tok == ')') // ([bd,An/PC,Xn]...
{
- //od is non existant, get out of jail free card
+ // od is non existent, get out of jail free card
//AnEXVAL=0; // zero outer displacement
AMn = MEMPRE; // 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++ != ',')
+ else if (*tok++ != ',')
return error("comma expected after ]");
if (*tok == SYMBOL || *tok == CONST)
// Defined, absolute values from $FFFF8000..$00007FFF
// get optimized to absolute short
- if (CHECK_OPTS(OPT_BASE_DISP)
+ if (CHECK_OPTS(OPT_BASE_DISP)
&& ((AnEXATTR & (TDB | DEFINED)) == DEFINED)
&& (((uint32_t)AnEXVAL + 0x8000) < 0x10000))
{
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
+ //AnBEXPR = AnEXPR;
+ AnBEXVAL = AnEXVAL;
+ AnBEXATTR = AnEXATTR;
+
+ if ((*tok >= KW_D0) && (*tok <= KW_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 == '*') // ([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++ != ')')
+ 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;
}
{
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!
+ 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 >= KW_IC40) && (*tok <= KW_BC40))
projects / rmac / blobdiff