X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?p=rmac;a=blobdiff_plain;f=parmode.h;h=4b6c7ea968c1f07a81e8d7ebedbed9a6a56efaee;hp=5ad5da90e1240e21bcd37da69a889228af048082;hb=ff8188b7e279f99cf11ac8a283c4146af324d26f;hpb=03dd34951a331e0b8971195ccef1600fffaea2e6 diff --git a/parmode.h b/parmode.h index 5ad5da9..4b6c7ea 100644 --- a/parmode.h +++ b/parmode.h @@ -78,6 +78,7 @@ { //Since index register isn't used here, store register number in this field AnIXREG = *tok++ & 7; // (Dn) + if (*tok == ')') { tok++; @@ -85,23 +86,23 @@ 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 << 1; // 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 = 1 << 1; // Word index size + tok++; } else if (*tok == ',') { @@ -115,7 +116,58 @@ goto CHECKODn; } else + { return error("(Dn) error"); + } + + if (*tok == '*') + { // scale: *1, *2, *4, *8 + tok++; + + if (*tok == SYMBOL) + { + if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK) + return error("scale factor expression must evaluate"); + + switch (AnEXVAL) + { + 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 || *tok > 8) + 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; + } + } + } if (*tok == ')') { @@ -128,6 +180,14 @@ 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... + goto CHECKODn; + } else return error("unhandled so far"); } @@ -173,27 +233,55 @@ { // scale: *1, *2, *4, *8 tok++; - if (*tok++ != CONST || *tok > 8) - goto badmode; - - switch ((int)*tok++) + if (*tok == SYMBOL) { - case 1: - break; - case 2: - AnIXSIZ |= TIMES2; - break; - case 4: - AnIXSIZ |= TIMES4; - break; - case 8: - AnIXSIZ |= TIMES8; - break; - default: + if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK) + return error("scale factor expression must evaluate"); + switch (AnEXVAL) + { + 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 || *tok > 8) 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; + } } } + if (*tok == ',') + { + tok++; + goto CHECKODn; + } if (*tok++ != ')') // final ")" goto badmode; @@ -202,44 +290,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; + { // ([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 +352,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)) @@ -280,52 +365,73 @@ tok++; // 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: - tok++; - break; - default: - break; - case DOTL: - AnEXTEN |= EXT_L; - tok++; - break; - case DOTB: - // .B not allowed here... - goto badmode; - } + // Index reg size: | .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 == 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(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK) + return error("scale factor expression must evaluate"); + + switch (AnEXVAL) + { + 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 || *tok > 8) 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; + } } } - if (*tok == ']') // ([bd,Dn]... { tok++; @@ -354,9 +460,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 +486,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,29 +512,52 @@ } // 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(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK) + return error("scale factor expression must evaluate"); + + switch (AnEXVAL) + { + 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 || *tok > 8) 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; + } } } @@ -441,17 +570,16 @@ 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 +594,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; @@ -487,9 +616,7 @@ // Is .W forced here? if (*tok == DOTW) - { tok++; - } } // Check for final closing parenthesis @@ -501,7 +628,7 @@ else return error("Closing parenthesis missing on addressing mode"); - IS_SUPPRESSEDn: +IS_SUPPRESSEDn: // Check for od if (*tok == ')') // ([bd,An/PC],Xn) @@ -522,7 +649,7 @@ 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 +678,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"); @@ -591,56 +717,76 @@ } // 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: - tok++; - break; - default: - break; - case DOTL: - tok++; - AnEXTEN |= EXT_L; - break; - case DOTB: - // .B not allowed here... - goto badmode; - } + // Index reg size: | .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 == 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(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK) + return error("scale factor expression must evaluate"); + switch (AnEXVAL) + { + 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 || *tok > 8) 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; + } } } //Check for ] if (*tok != ']') return error("Expected closing bracket ]"); - tok++; // Eat the bracket //Check for od @@ -653,21 +799,22 @@ 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 +828,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 +917,7 @@ } else if (*tok == ')') { - AMn = PCDISP; // expr(PC) + AMn = PCDISP; // expr(PC) tok++; goto AnOK; } @@ -805,7 +961,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 +1010,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 +1058,7 @@ CHK_FOR_DISPn: AMn = PCINDEXED; goto AMn_IXN; } + goto badmode; }