X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?p=rmac;a=blobdiff_plain;f=parmode.h;h=20f0973becf494dc445bbc689c45cb36c28882d9;hp=5ad5da90e1240e21bcd37da69a889228af048082;hb=8a5d76b0e6c7433cdbdf3d612da5c209516cb594;hpb=03dd34951a331e0b8971195ccef1600fffaea2e6 diff --git a/parmode.h b/parmode.h index 5ad5da9..20f0973 100644 --- a/parmode.h +++ b/parmode.h @@ -9,6 +9,11 @@ // 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 @@ -44,10 +49,10 @@ // (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++; @@ -78,6 +83,7 @@ { //Since index register isn't used here, store register number in this field AnIXREG = *tok++ & 7; // (Dn) + if (*tok == ')') { tok++; @@ -85,23 +91,21 @@ AnEXTEN |= EXT_BS; // Base register suppressed AnEXTEN |= EXT_BDSIZE0; // Base displacement null AnEXTEN |= EXT_IISPOSN; // Indirect Postindexed with Null Outer Displacement - AMn= MEMPOST; + AMn = MEMPOST; AnREG = 6 << 3; // stuff 110 to mode field goto AnOK; } else if (*tok == 'L') { - // TODO: does DINDL gets used at all? - //AMn=DINDL; // (Dn.l) - //AnEXTEN = 1 << 1; // Long index size - //tok++; + 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 - //tok++; + AMn = DINDW; + AnEXTEN = 0 << 11; // Word index size + tok++; } else if (*tok == ',') { @@ -115,7 +119,66 @@ 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 == ')') { @@ -128,6 +191,15 @@ 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_BDSIZE0; // Base displacement null - suppressed + goto CHECKODn; + } else return error("unhandled so far"); } @@ -173,27 +245,61 @@ { // scale: *1, *2, *4, *8 tok++; - if (*tok++ != CONST || *tok > 8) + 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; + } - 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; @@ -202,44 +308,41 @@ 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 - //WARNING("expr will return a bad expression error here but this is expected, it needs to be silenced!"); - if (*tok!=CONST && *tok !=SYMBOL) - //if (expr(AnBEXPR, &AnBEXVAL, &AnBEXATTR, &AnESYM) != OK) + if (*tok != CONST && *tok != SYMBOL) { - AnEXTEN|=EXT_BDSIZE0; - //tok++; - //tok--; //Rewind tok since expr advances it forward + AnEXTEN |= EXT_BDSIZE0; } else { expr(AnBEXPR, &AnBEXVAL, &AnBEXATTR, &AnESYM); - if (optim_flags[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,... - AnEXTEN|=EXT_BDSIZEL; + else if (*tok == DOTL) + { // ([bd.l,... + AnEXTEN |= EXT_BDSIZEL; tok++; } else - { // ([bd[.w],... or ([bd,... + { // ([bd[.w],... or ([bd,... // Is .W forced here? if (*tok == DOTW) { - AnEXTEN|=EXT_BDSIZEW; + AnEXTEN |= EXT_BDSIZEW; tok++; } else { // Defined, absolute values from $FFFF8000..$00007FFF get optimized // to absolute short - if (optim_flags[OPT_ABS_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"); @@ -267,7 +370,7 @@ } 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)) @@ -283,7 +386,7 @@ { // ([bd,An/PC],Xn.W/L...) switch ((int)*tok) - { + { // Index reg size: | .W | .L case DOTW: tok++; @@ -302,30 +405,55 @@ // Check for scale if (*tok == '*') // ([bd,An/PC],Xn*...) - { + { // scale: *1, *2, *4, *8 tok++; - if (*tok == CONST) // TODO: I suppose the scale is stored as a CONST and nothing else? So prolly the if is not needed? - tok++; - - switch ((int)*tok++) + if (*tok == SYMBOL) { - case 1: - break; - case 2: - AnEXTEN |= EXT_TIMES2; - break; - case 4: - AnEXTEN |= EXT_TIMES4; - break; - case 8: - AnEXTEN |= EXT_TIMES8; - break; - default: + 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++; @@ -354,9 +482,9 @@ if (*tok == ')') { //Xn and od are non existent, get out of jail free card + tok++; AMn = MEMPRE; // ([bc,An,Xn],od) with no Xn and od AnEXTEN |= EXT_IS | EXT_IISPREN; //Suppress Xn and od - tok++; goto AnOK; } else if (*tok != ',') @@ -380,8 +508,8 @@ { //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? + tok--; // Rewind tok to point to the comma + goto IS_SUPPRESSEDn; // https://xkcd.com/292/ - what does he know anyway? } // Check for size @@ -406,52 +534,76 @@ } // Check for scale - if (*tok == '*') - { - // ([bd,An/PC],Xn*...) + if (*tok == '*') // ([bd,An/PC],Xn*...) + { // scale: *1, *2, *4, *8 tok++; - if (*tok == CONST) // TODO: I suppose the scale is stored as a CONST and nothing else? So prolly the if is not needed? - tok++; - - switch ((int)*tok++) + if (*tok == SYMBOL) { - case 1: - break; - case 2: - AnEXTEN |= EXT_TIMES2; - break; - case 4: - AnEXTEN |= EXT_TIMES4; - break; - case 8: - AnEXTEN |= EXT_TIMES8; - break; - default: + 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 } } // 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++; goto AnOK; } - else if (*tok!=',') + else if (*tok != ',') return error("comma expected"); else tok++; // eat the comma CHECKODn: - if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK) goto badmode; - if (optim_flags[OPT_BASE_DISP] && (AnEXVAL == 0)) + if (CHECK_OPTS(OPT_BASE_DISP) && (AnEXVAL == 0)) { // od=0 so optimise it out AMn = MEMPOST; // let's say it's ([bd,An],Xn,od) with od=0 then @@ -466,12 +618,13 @@ // expr.L AnEXTEN |= EXT_IISPOSL; // Long outer displacement AMn = MEMPOST; + tok++; // Defined, absolute values from $FFFF8000..$00007FFF get // optimized to absolute short - if (optim_flags[OPT_ABS_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; @@ -501,12 +654,12 @@ else return error("Closing parenthesis missing on addressing mode"); - IS_SUPPRESSEDn: +IS_SUPPRESSEDn: // 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++; @@ -517,12 +670,12 @@ else tok++; // eat the comma - if ((*tok != CONST) && (*tok != SYMBOL)) + if ((*tok != CONST) && (*tok != SYMBOL)) goto badmode; expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM); - if (optim_flags[OPT_BASE_DISP] && (AnEXVAL == 0)) + if (CHECK_OPTS(OPT_BASE_DISP) && (AnEXVAL == 0)) { // od=0 so optimise it out AMn = MEMPOST; // let's say it's ([bd,An],Xn,od) with od=0 then @@ -551,12 +704,11 @@ AMn = MEMPOST; tok++; } - // Defined, absolute values from $FFFF8000..$00007FFF get // optimized to absolute short - else if (optim_flags[OPT_BASE_DISP] + 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"); @@ -592,8 +744,8 @@ // Check for size { - // ([bd,An/PC],Xn.W/L...) - switch ((int)*tok) + // ([bd,An/PC],Xn.W/L...) + switch ((int)*tok) { // Index reg size: | .W | .L case DOTW: @@ -606,68 +758,96 @@ AnEXTEN |= EXT_L; break; case DOTB: - // .B not allowed here... - goto badmode; + // .B not allowed here... + goto badmode; } } // Check for scale if (*tok == '*') // ([bd,An/PC],Xn*...) - { + { // scale: *1, *2, *4, *8 tok++; - if (*tok == CONST) // TODO: I suppose the scale is stored as a CONST and nothing else? So prolly the if is not needed? - tok++; - - switch ((int)*tok++) + if (*tok == SYMBOL) { - case 1: - break; - case 2: - AnEXTEN |= EXT_TIMES2; - break; - case 4: - AnEXTEN |= EXT_TIMES4; - break; - case 8: - AnEXTEN |= EXT_TIMES8; - break; - default: + 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 ] + // 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 ]"); - WARNING(Put symbol and constant checks here!) - - if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK) - goto badmode; - - if (optim_flags[OPT_BASE_DISP] && (AnEXVAL == 0)) + if (*tok == SYMBOL || *tok == CONST) { - // od=0 so optimise it out - AMn = MEMPRE; // let's say it's ([bd,An],Xn,od) with od=0 then - AnEXTEN |= EXT_IISPRE0; // No outer displacement - tok++; - goto AnOK; + if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK) + goto badmode; + + if (CHECK_OPTS(OPT_BASE_DISP) && (AnEXVAL == 0) && (AnEXATTR & DEFINED)) + { + // od=0 so optimise it out + AMn = MEMPRE; // 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) @@ -681,25 +861,34 @@ else { // expr.[W] - //tok++; - - AnEXTEN |= EXT_IISPREW; AMn = MEMPRE; + int expr_size = EXT_IISPREW; // Assume we have a .w value - // Is .W forced here? - if (*tok == DOTW) + if ((AnEXVAL + 0x8000) > 0x10000) { - tok++; + // 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_BASE_DISP) + && ((AnEXATTR & (TDB | DEFINED)) == DEFINED) + && (((uint32_t)AnEXVAL + 0x8000) < 0x10000)) + { + expr_size = EXT_IISPREW; + warn("outer displacement absolute value from $FFFF8000..$00007FFF optimised to absolute short"); + } } - // Defined, absolute values from $FFFF8000..$00007FFF get optimized - // to absolute short - else if (optim_flags[OPT_BASE_DISP] - && ((AnEXATTR & (TDB | DEFINED)) == DEFINED) - && ((AnEXVAL + 0x8000) < 0x10000)) + AnEXTEN |= expr_size; // Assume we have a .w value + + // Is .W forced here? + if (*tok == DOTW) { - AnEXTEN |= EXT_IISPREW; - warn("outer displacement absolute value from $FFFF8000..$00007FFF optimised to absolute short"); + tok++; + + if (expr_size == EXT_IISPREL) + return error("outer displacement value does not fit in .w size"); } } @@ -761,7 +950,7 @@ } else if (*tok == ')') { - AMn = PCDISP; // expr(PC) + AMn = PCDISP; // expr(PC) tok++; goto AnOK; } @@ -794,7 +983,7 @@ { 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)) @@ -805,7 +994,6 @@ // After a cache keyword only a comma or EOL is allowed if ((*tok != ',') && (*tok != EOL)) return ERROR; - goto AnOK; } else if ((*tok >= KW_SFC) && (*tok <= KW_CRP)) @@ -855,9 +1043,9 @@ CHK_FOR_DISPn: // Defined, absolute values from $FFFF8000..$00007FFF get optimized // to absolute short - if (optim_flags[OPT_ABS_SHORT] + if (CHECK_OPTS(OPT_ABS_SHORT) && ((AnEXATTR & (TDB | DEFINED)) == DEFINED) - && ((AnEXVAL + 0x8000) < 0x10000)) + && (((uint32_t)AnEXVAL + 0x8000) < 0x10000)) { AMn = ABSW; @@ -903,6 +1091,7 @@ CHK_FOR_DISPn: AMn = PCINDEXED; goto AMn_IXN; } + goto badmode; }