X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?p=rmac;a=blobdiff_plain;f=parmode.h;h=955fade88621de27095dad9fba6f613c8498f76f;hp=4637d72dda1bca9613a2484de82f4bf68ffb9f4c;hb=HEAD;hpb=3385b366632d03745033fa6b19faabf60219bc6b diff --git a/parmode.h b/parmode.h index 4637d72..27863d0 100644 --- a/parmode.h +++ b/parmode.h @@ -1,35 +1,42 @@ // -// RMAC - Reboot's Macro Assembler for the Atari Jaguar Console System +// RMAC - Renamed Macro Assembler for all Atari computers // PARMODE.C - Addressing Modes Parser Include -// Copyright (C) 199x Landon Dyer, 2011 Reboot and Friends +// 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 +// 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 >= KW_D0) && (*tok <= KW_D7)) + if ((*tok >= REG68_D0) && (*tok <= REG68_D7)) { AMn = DREG; AnREG = *tok++ & 7; } - else if ((*tok >= KW_A0) && (*tok <= KW_A7)) + else if ((*tok >= REG68_A0) && (*tok <= REG68_A7)) { AMn = AREG; AnREG = *tok++ & 7; } else if (*tok == '#') { - ++tok; + tok++; + if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK) return ERROR; AMn = IMMED; } + // (An) // (An)+ // (An,Xn[.siz][*scale]) @@ -38,25 +45,26 @@ // (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; + int ea_PC = 0; // Flag that let us know if we have PC or An relative ea + tok++; - if ((*tok >= KW_A0) && (*tok <= KW_A7)) + if ((*tok >= REG68_A0) && (*tok <= REG68_A7)) { AnREG = *tok++ & 7; if (*tok == ')') { - ++tok; + tok++; if (*tok == '+') { - ++tok; + tok++; AMn = APOSTINC; } else @@ -66,106 +74,1049 @@ } AMn = AINDEXED; - goto AMn_IX0; // Handle ",Xn[.siz][*scale])" + goto AMn_IX0; // Handle ",Xn[.siz][*scale])" } - else if (*tok == KW_PC) - { // (PC,Xn[.siz][*scale]) - ++tok; + 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. + // Common index handler; enter here with 'tok' pointing at the + // comma. - AMn_IX0: // Handle indexed with missing expr +AMn_IX0: // Handle indexed with missing expr AnEXVAL = 0; AnEXATTR = ABS | DEFINED; - AMn_IXN: // Handle any indexed (tok -> a comma) +AMn_IXN: // Handle any indexed (tok -> a comma) if (*tok++ != ',') goto badmode; - if (*tok < KW_D0 || *tok > KW_A7) + if (*tok < REG68_D0 || *tok > REG68_A7) goto badmode; AnIXREG = *tok++ & 15; switch ((int)*tok) - { // Index reg size: | .W | .L + { // Index reg size: | .W | .L case DOTW: - ++tok; + tok++; default: AnIXSIZ = 0; break; case DOTL: AnIXSIZ = 0x0800; - ++tok; + tok++; break; - case DOTB: // .B not allowed here... + case DOTB: // .B not allowed here... goto badmode; } if (*tok == '*') - { // scale: *1, *2, *4, *8 - ++tok; - if (*tok++ != CONST || *tok > 8) + { // 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++; - switch ((int)*tok++) + // Check for size + // ([bd,An/PC],Xn.W/L...) + switch ((int)*tok) { - case 1: + // Index reg size: | .W | .L + case DOTW: + tok++; break; - case 2: - AnIXSIZ |= TIMES2; + default: break; - case 4: - AnIXSIZ |= TIMES4; + case DOTL: + AnEXTEN |= EXT_L; + tok++; break; - case 8: - AnIXSIZ |= TIMES8; + 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: | .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) - if (*tok++ != ')') // final ")" + // 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: | .W | .L + case DOTW: + tok++; + break; + default: + break; + case DOTL: + tok++; + AnEXTEN |= EXT_L; + break; + case DOTB: + // .B not allowed here... goto badmode; + } - goto AnOK; - } - else if (*tok == '[') - { // ([... - goto unmode; + // 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... + { + // (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 >= KW_A0) && (*tok <= KW_A7)) + if ((*tok >= REG68_A0) && (*tok <= REG68_A7)) { AnREG = *tok & 7; - ++tok; + 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: | .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; + tok++; goto AnOK; } else goto badmode; } - else if (*tok == KW_PC) + else if (*tok == REG68_PC) { if (*++tok == ',') { // expr(PC,Xn...) @@ -174,8 +1125,8 @@ } else if (*tok == ')') { - AMn = PCDISP; // expr(PC) - ++tok; + AMn = PCDISP; // expr(PC) + tok++; goto AnOK; } else @@ -185,30 +1136,57 @@ goto badmode; } } - else if (*tok=='-' && tok[1]=='(' && ((tok[2]>=KW_A0) && (tok[2]<=KW_A7)) && tok[3]==')') + 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 == KW_CCR) + else if (*tok == REG68_CCR) { AMn = AM_CCR; - ++tok; + tok++; goto AnOK; } - else if (*tok == KW_SR) + else if (*tok == REG68_SR) { AMn = AM_SR; - ++tok; + tok++; goto AnOK; } - else if (*tok == KW_USP) + else if (*tok == REG68_USP) { AMn = AM_USP; - ++tok; + 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 @@ -221,67 +1199,89 @@ if (expr(AnEXPR, &AnEXVAL, &AnEXATTR, &AnESYM) != OK) return ERROR; +CHK_FOR_DISPn: if (*tok == DOTW) - { // expr.W - ++tok; + { + // 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] + { + // expr[.L] AMn = ABSL; - // Defined, absolute values from $FFFF8000..$00007FFF get optimized to absolute short - - if ((AnEXATTR & (TDB|DEFINED)) == DEFINED && (AnEXVAL + 0x8000) < 0x10000) - AMn = ABSW; + // .L is forced here if (*tok == DOTL) - { // force .L - ++tok; - AMn = ABSL; + { + // 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; + tok++; - if ((*tok >= KW_A0) && (*tok <= KW_A7)) + if ((*tok >= REG68_A0) && (*tok <= REG68_A7)) { AnREG = *tok++ & 7; if (*tok == ')') { AMn = ADISP; - ++tok; + tok++; goto AnOK; } AMn = AINDEXED; goto AMn_IXN; } - else if (*tok == KW_PC) + else if (*tok == REG68_PC) { if (*++tok == ')') { AMn = PCDISP; - ++tok; + tok++; goto AnOK; } AMn = PCINDEXED; goto AMn_IXN; } + goto badmode; } // Addressing mode OK - - AnOK: +AnOK: ; } -// Cleanup dirty little macros +// Clean up dirty little macros #undef AnOK #undef AMn #undef AnREG @@ -296,3 +1296,12 @@ #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