static void build_insn (int insn)
{
int find = -1;
int variants;
struct instr_def id;
const char *opcstr;
int i;
int flaglive = 0, flagdead = 0;
id = defs68k[insn];
for (i = 0; i < 5; i++) {
switch (id.flaginfo[i].flagset){
case fa_unset: break;
case fa_isjmp: break;
case fa_zero: flagdead |= 1 << i; break;
case fa_one: flagdead |= 1 << i; break;
case fa_dontcare: flagdead |= 1 << i; break;
case fa_unknown: flagdead = -1; goto out1;
case fa_set: flagdead |= 1 << i; break;
}
}
out1:
for (i = 0; i < 5; i++) {
switch (id.flaginfo[i].flaguse) {
case fu_unused: break;
case fu_isjmp: flaglive |= 1 << i; break;
case fu_maybecc: flaglive |= 1 << i; break;
case fu_unknown: flaglive = -1; goto out2;
case fu_used: flaglive |= 1 << i; break;
}
}
out2:
opcstr = id.opcstr;
for (variants = 0; variants < (1 << id.n_variable); variants++) {
int bitcnt[lastbit];
int bitval[lastbit];
int bitpos[lastbit];
int i;
uae_u16 opc = id.bits;
uae_u16 msk, vmsk;
int pos = 0;
int mnp = 0;
int bitno = 0;
char mnemonic[10];
wordsizes sz = sz_long;
int srcgather = 0, dstgather = 0;
int usesrc = 0, usedst = 0;
int srctype = 0;
int srcpos = -1, dstpos = -1;
amodes srcmode = am_unknown, destmode = am_unknown;
int srcreg = -1, destreg = -1;
for (i = 0; i < lastbit; i++)
bitcnt[i] = bitval[i] = 0;
vmsk = 1 << id.n_variable;
for (i = 0, msk = 0x8000; i < 16; i++, msk >>= 1) {
if (!(msk & id.mask)) {
int currbit = id.bitpos[bitno++];
int bit_set;
vmsk >>= 1;
bit_set = variants & vmsk ? 1 : 0;
if (bit_set)
opc |= msk;
bitpos[currbit] = 15 - i;
bitcnt[currbit]++;
bitval[currbit] <<= 1;
bitval[currbit] |= bit_set;
}
}
if (bitval[bitj] == 0) bitval[bitj] = 8;
/* first check whether this one does not match after all */
if (bitval[bitz] == 3 || bitval[bitC] == 1)
continue;
if (bitcnt[bitI] && (bitval[bitI] == 0x00 || bitval[bitI] == 0xff))
continue;
/* bitI and bitC get copied to biti and bitc */
if (bitcnt[bitI]) {
bitval[biti] = bitval[bitI]; bitpos[biti] = bitpos[bitI];
}
if (bitcnt[bitC])
bitval[bitc] = bitval[bitC];
pos = 0;
while (opcstr[pos] && !isspace(opcstr[pos])) {
if (opcstr[pos] == '.') {
pos++;
switch (opcstr[pos]) {
case 'B': sz = sz_byte; break;
case 'W': sz = sz_word; break;
case 'L': sz = sz_long; break;
case 'z':
switch (bitval[bitz]) {
case 0: sz = sz_byte; break;
case 1: sz = sz_word; break;
case 2: sz = sz_long; break;
default: abort();
}
break;
default: abort();
}
} else {
mnemonic[mnp] = opcstr[pos];
if (mnemonic[mnp] == 'f') {
find = -1;
switch (bitval[bitf]) {
case 0: mnemonic[mnp] = 'R'; break;
case 1: mnemonic[mnp] = 'L'; break;
default: abort();
}
}
mnp++;
}
pos++;
}
mnemonic[mnp] = 0;
/* now, we have read the mnemonic and the size */
while (opcstr[pos] && isspace(opcstr[pos]))
pos++;
/* A goto a day keeps the D******a away. */
if (opcstr[pos] == 0)
goto endofline;
/* parse the source address */
usesrc = 1;
switch (opcstr[pos++]) {
case 'D':
srcmode = Dreg;
switch (opcstr[pos++]) {
case 'r': srcreg = bitval[bitr]; srcgather = 1; srcpos = bitpos[bitr]; break;
case 'R': srcreg = bitval[bitR]; srcgather = 1; srcpos = bitpos[bitR]; break;
default: abort();
}
break;
case 'A':
srcmode = Areg;
switch (opcstr[pos++]) {
case 'r': srcreg = bitval[bitr]; srcgather = 1; srcpos = bitpos[bitr]; break;
case 'R': srcreg = bitval[bitR]; srcgather = 1; srcpos = bitpos[bitR]; break;
default: abort();
}
switch (opcstr[pos]) {
case 'p': srcmode = Apdi; pos++; break;
case 'P': srcmode = Aipi; pos++; break;
}
break;
case '#':
switch (opcstr[pos++]) {
case 'z': srcmode = imm; break;
case '0': srcmode = imm0; break;
case '1': srcmode = imm1; break;
case '2': srcmode = imm2; break;
case 'i': srcmode = immi; srcreg = (uae_s32)(uae_s8)bitval[biti];
if (CPU_EMU_SIZE < 4) {
/* Used for branch instructions */
srctype = 1;
srcgather = 1;
srcpos = bitpos[biti];
}
break;
case 'j': srcmode = immi; srcreg = bitval[bitj];
if (CPU_EMU_SIZE < 3) {
/* 1..8 for ADDQ/SUBQ and rotshi insns */
srcgather = 1;
srctype = 3;
srcpos = bitpos[bitj];
}
break;
case 'J': srcmode = immi; srcreg = bitval[bitJ];
if (CPU_EMU_SIZE < 5) {
/* 0..15 */
srcgather = 1;
srctype = 2;
srcpos = bitpos[bitJ];
}
break;
case 'k': srcmode = immi; srcreg = bitval[bitk];
if (CPU_EMU_SIZE < 3) {
srcgather = 1;
srctype = 4;
srcpos = bitpos[bitk];
}
break;
case 'K': srcmode = immi; srcreg = bitval[bitK];
if (CPU_EMU_SIZE < 5) {
/* 0..15 */
srcgather = 1;
srctype = 5;
srcpos = bitpos[bitK];
}
break;
default: abort();
}
break;
case 'd':
srcreg = bitval[bitD];
srcmode = mode_from_mr(bitval[bitd],bitval[bitD]);
if (srcmode == am_illg)
continue;
if (CPU_EMU_SIZE < 2 &&
(srcmode == Areg || srcmode == Dreg || srcmode == Aind
|| srcmode == Ad16 || srcmode == Ad8r || srcmode == Aipi
|| srcmode == Apdi))
{
srcgather = 1; srcpos = bitpos[bitD];
}
if (opcstr[pos] == '[') {
pos++;
if (opcstr[pos] == '!') {
/* exclusion */
do {
pos++;
if (mode_from_str(opcstr+pos) == srcmode)
goto nomatch;
pos += 4;
} while (opcstr[pos] == ',');
pos++;
} else {
if (opcstr[pos+4] == '-') {
/* replacement */
if (mode_from_str(opcstr+pos) == srcmode)
srcmode = mode_from_str(opcstr+pos+5);
else
goto nomatch;
pos += 10;
} else {
/* normal */
while(mode_from_str(opcstr+pos) != srcmode) {
pos += 4;
if (opcstr[pos] == ']')
goto nomatch;
pos++;
}
while(opcstr[pos] != ']') pos++;
pos++;
break;
}
}
}
/* Some addressing modes are invalid as destination */
if (srcmode == imm || srcmode == PC16 || srcmode == PC8r)
goto nomatch;
break;
case 's':
srcreg = bitval[bitS];
srcmode = mode_from_mr(bitval[bits],bitval[bitS]);
if (srcmode == am_illg)
continue;
if (CPU_EMU_SIZE < 2 &&
(srcmode == Areg || srcmode == Dreg || srcmode == Aind
|| srcmode == Ad16 || srcmode == Ad8r || srcmode == Aipi
|| srcmode == Apdi))
{
srcgather = 1; srcpos = bitpos[bitS];
}
if (opcstr[pos] == '[') {
pos++;
if (opcstr[pos] == '!') {
/* exclusion */
do {
pos++;
if (mode_from_str(opcstr+pos) == srcmode)
goto nomatch;
pos += 4;
} while (opcstr[pos] == ',');
pos++;
} else {
if (opcstr[pos+4] == '-') {
/* replacement */
if (mode_from_str(opcstr+pos) == srcmode)
srcmode = mode_from_str(opcstr+pos+5);
else
goto nomatch;
pos += 10;
} else {
/* normal */
while(mode_from_str(opcstr+pos) != srcmode) {
pos += 4;
if (opcstr[pos] == ']')
goto nomatch;
pos++;
}
while(opcstr[pos] != ']') pos++;
pos++;
}
}
}
break;
default: abort();
}
/* safety check - might have changed */
if (srcmode != Areg && srcmode != Dreg && srcmode != Aind
&& srcmode != Ad16 && srcmode != Ad8r && srcmode != Aipi
&& srcmode != Apdi && srcmode != immi)
{
srcgather = 0;
}
if (srcmode == Areg && sz == sz_byte)
goto nomatch;
if (opcstr[pos] != ',')
goto endofline;
pos++;
/* parse the destination address */
usedst = 1;
switch (opcstr[pos++]) {
case 'D':
destmode = Dreg;
switch (opcstr[pos++]) {
case 'r': destreg = bitval[bitr]; dstgather = 1; dstpos = bitpos[bitr]; break;
case 'R': destreg = bitval[bitR]; dstgather = 1; dstpos = bitpos[bitR]; break;
default: abort();
}
break;
case 'A':
destmode = Areg;
switch (opcstr[pos++]) {
case 'r': destreg = bitval[bitr]; dstgather = 1; dstpos = bitpos[bitr]; break;
case 'R': destreg = bitval[bitR]; dstgather = 1; dstpos = bitpos[bitR]; break;
default: abort();
}
switch (opcstr[pos]) {
case 'p': destmode = Apdi; pos++; break;
case 'P': destmode = Aipi; pos++; break;
}
break;
case '#':
switch (opcstr[pos++]) {
case 'z': destmode = imm; break;
case '0': destmode = imm0; break;
case '1': destmode = imm1; break;
case '2': destmode = imm2; break;
case 'i': destmode = immi; destreg = (uae_s32)(uae_s8)bitval[biti]; break;
case 'j': destmode = immi; destreg = bitval[bitj]; break;
case 'J': destmode = immi; destreg = bitval[bitJ]; break;
case 'k': destmode = immi; destreg = bitval[bitk]; break;
case 'K': destmode = immi; destreg = bitval[bitK]; break;
default: abort();
}
break;
case 'd':
destreg = bitval[bitD];
destmode = mode_from_mr(bitval[bitd],bitval[bitD]);
if (destmode == am_illg)
continue;
if (CPU_EMU_SIZE < 1 &&
(destmode == Areg || destmode == Dreg || destmode == Aind
|| destmode == Ad16 || destmode == Ad8r || destmode == Aipi
|| destmode == Apdi))
{
dstgather = 1; dstpos = bitpos[bitD];
}
if (opcstr[pos] == '[') {
pos++;
if (opcstr[pos] == '!') {
/* exclusion */
do {
pos++;
if (mode_from_str(opcstr+pos) == destmode)
goto nomatch;
pos += 4;
} while (opcstr[pos] == ',');
pos++;
} else {
if (opcstr[pos+4] == '-') {
/* replacement */
if (mode_from_str(opcstr+pos) == destmode)
destmode = mode_from_str(opcstr+pos+5);
else
goto nomatch;
pos += 10;
} else {
/* normal */
while(mode_from_str(opcstr+pos) != destmode) {
pos += 4;
if (opcstr[pos] == ']')
goto nomatch;
pos++;
}
while(opcstr[pos] != ']') pos++;
pos++;
break;
}
}
}
/* Some addressing modes are invalid as destination */
if (destmode == imm || destmode == PC16 || destmode == PC8r)
goto nomatch;
break;
case 's':
destreg = bitval[bitS];
destmode = mode_from_mr(bitval[bits],bitval[bitS]);
if (destmode == am_illg)
continue;
if (CPU_EMU_SIZE < 1 &&
(destmode == Areg || destmode == Dreg || destmode == Aind
|| destmode == Ad16 || destmode == Ad8r || destmode == Aipi
|| destmode == Apdi))
{
dstgather = 1; dstpos = bitpos[bitS];
}
if (opcstr[pos] == '[') {
pos++;
if (opcstr[pos] == '!') {
/* exclusion */
do {
pos++;
if (mode_from_str(opcstr+pos) == destmode)
goto nomatch;
pos += 4;
} while (opcstr[pos] == ',');
pos++;
} else {
if (opcstr[pos+4] == '-') {
/* replacement */
if (mode_from_str(opcstr+pos) == destmode)
destmode = mode_from_str(opcstr+pos+5);
else
goto nomatch;
pos += 10;
} else {
/* normal */
while(mode_from_str(opcstr+pos) != destmode) {
pos += 4;
if (opcstr[pos] == ']')
goto nomatch;
pos++;
}
while(opcstr[pos] != ']') pos++;
pos++;
}
}
}
break;
default: abort();
}
/* safety check - might have changed */
if (destmode != Areg && destmode != Dreg && destmode != Aind
&& destmode != Ad16 && destmode != Ad8r && destmode != Aipi
&& destmode != Apdi)
{
dstgather = 0;
}
if (destmode == Areg && sz == sz_byte)
goto nomatch;
#if 0
if (sz == sz_byte && (destmode == Aipi || destmode == Apdi)) {
dstgather = 0;
}
#endif
endofline:
/* now, we have a match */
if (table68k[opc].mnemo != i_ILLG)
fprintf(stderr, "UAE: Double match: %x: %s\n", opc, opcstr);
if (find == -1) {
for (find = 0;; find++) {
if (strcmp(mnemonic, lookuptab[find].name) == 0) {
table68k[opc].mnemo = lookuptab[find].mnemo;
break;
}
if (strlen(lookuptab[find].name) == 0) abort();
}
}
else {
table68k[opc].mnemo = lookuptab[find].mnemo;
}
table68k[opc].cc = bitval[bitc];
if (table68k[opc].mnemo == i_BTST
|| table68k[opc].mnemo == i_BSET
|| table68k[opc].mnemo == i_BCLR
|| table68k[opc].mnemo == i_BCHG)
{
sz = destmode == Dreg ? sz_long : sz_byte;
}
table68k[opc].size = sz;
table68k[opc].sreg = srcreg;
table68k[opc].dreg = destreg;
table68k[opc].smode = srcmode;
table68k[opc].dmode = destmode;
table68k[opc].spos = srcgather ? srcpos : -1;
table68k[opc].dpos = dstgather ? dstpos : -1;
table68k[opc].suse = usesrc;
table68k[opc].duse = usedst;
table68k[opc].stype = srctype;
table68k[opc].plev = id.plevel;
table68k[opc].clev = id.cpulevel;
#if 0
for (i = 0; i < 5; i++) {
table68k[opc].flaginfo[i].flagset = id.flaginfo[i].flagset;
table68k[opc].flaginfo[i].flaguse = id.flaginfo[i].flaguse;
}
#endif
table68k[opc].flagdead = flagdead;
table68k[opc].flaglive = flaglive;
nomatch:
/* FOO! */;
}
static void build_insn (int insn)
{
int find = -1;
int variants;
struct instr_def id;
const char *opcstr;
int i, n;
int flaglive = 0, flagdead = 0;
int cflow = 0;
id = defs68k[insn];
// Control flow information
cflow = id.cflow;
// Mask of flags set/used
unsigned char flags_set(0), flags_used(0);
for (i = 0, n = 4; i < 5; i++, n--) {
switch (id.flaginfo[i].flagset) {
case fa_unset: case fa_isjmp: break;
default: flags_set |= (1 << n);
}
switch (id.flaginfo[i].flaguse) {
case fu_unused: case fu_isjmp: break;
default: flags_used |= (1 << n);
}
}
for (i = 0; i < 5; i++) {
switch (id.flaginfo[i].flagset){
case fa_unset: break;
case fa_zero: flagdead |= 1 << i; break;
case fa_one: flagdead |= 1 << i; break;
case fa_dontcare: flagdead |= 1 << i; break;
case fa_unknown: flagdead = -1; goto out1;
case fa_set: flagdead |= 1 << i; break;
}
}
out1:
for (i = 0; i < 5; i++) {
switch (id.flaginfo[i].flaguse) {
case fu_unused: break;
case fu_unknown: flaglive = -1; goto out2;
case fu_used: flaglive |= 1 << i; break;
}
}
out2:
opcstr = id.opcstr;
for (variants = 0; variants < (1 << id.n_variable); variants++) {
int bitcnt[lastbit];
int bitval[lastbit];
int bitpos[lastbit];
int i;
uae_u16 opc = id.bits;
uae_u16 msk, vmsk;
int pos = 0;
int mnp = 0;
int bitno = 0;
char mnemonic[64];
wordsizes sz = sz_long;
int srcgather = 0, dstgather = 0;
int usesrc = 0, usedst = 0;
int srctype = 0;
int srcpos = -1, dstpos = -1;
amodes srcmode = am_unknown, destmode = am_unknown;
int srcreg = -1, destreg = -1;
for (i = 0; i < lastbit; i++)
bitcnt[i] = bitval[i] = 0;
vmsk = 1 << id.n_variable;
for (i = 0, msk = 0x8000; i < 16; i++, msk >>= 1) {
if (!(msk & id.mask)) {
int currbit = id.bitpos[bitno++];
int bit_set;
vmsk >>= 1;
bit_set = variants & vmsk ? 1 : 0;
if (bit_set)
opc |= msk;
bitpos[currbit] = 15 - i;
bitcnt[currbit]++;
bitval[currbit] <<= 1;
bitval[currbit] |= bit_set;
}
}
if (bitval[bitj] == 0) bitval[bitj] = 8;
/* first check whether this one does not match after all */
if (bitval[bitz] == 3 || bitval[bitC] == 1)
continue;
if (bitcnt[bitI] && (bitval[bitI] == 0x00 || bitval[bitI] == 0xff))
continue;
if (bitcnt[bitE] && (bitval[bitE] == 0x00))
continue;
/* bitI and bitC get copied to biti and bitc */
if (bitcnt[bitI]) {
bitval[biti] = bitval[bitI]; bitpos[biti] = bitpos[bitI];
}
if (bitcnt[bitC])
bitval[bitc] = bitval[bitC];
pos = 0;
while (opcstr[pos] && !isspace(opcstr[pos])) {
if (opcstr[pos] == '.') {
pos++;
switch (opcstr[pos]) {
case 'B': sz = sz_byte; break;
case 'W': sz = sz_word; break;
case 'L': sz = sz_long; break;
case 'z':
switch (bitval[bitz]) {
case 0: sz = sz_byte; break;
case 1: sz = sz_word; break;
case 2: sz = sz_long; break;
default: abort();
}
break;
default: abort();
}
} else {
mnemonic[mnp] = opcstr[pos];
if (mnemonic[mnp] == 'f') {
find = -1;
switch (bitval[bitf]) {
case 0: mnemonic[mnp] = 'R'; break;
case 1: mnemonic[mnp] = 'L'; break;
default: abort();
}
}
mnp++;
if ((unsigned)mnp >= sizeof(mnemonic) - 1) {
mnemonic[sizeof(mnemonic) - 1] = 0;
fprintf(stderr, "Instruction %s overflow\n", mnemonic);
abort();
}
}
pos++;
}
mnemonic[mnp] = 0;
/* now, we have read the mnemonic and the size */
while (opcstr[pos] && isspace(opcstr[pos]))
pos++;
/* A goto a day keeps the D******a away. */
if (opcstr[pos] == 0)
goto endofline;
/* parse the source address */
usesrc = 1;
switch (opcstr[pos++]) {
case 'D':
srcmode = Dreg;
switch (opcstr[pos++]) {
case 'r': srcreg = bitval[bitr]; srcgather = 1; srcpos = bitpos[bitr]; break;
case 'R': srcreg = bitval[bitR]; srcgather = 1; srcpos = bitpos[bitR]; break;
default: abort();
}
break;
case 'A':
srcmode = Areg;
switch (opcstr[pos++]) {
case 'r': srcreg = bitval[bitr]; srcgather = 1; srcpos = bitpos[bitr]; break;
case 'R': srcreg = bitval[bitR]; srcgather = 1; srcpos = bitpos[bitR]; break;
default: abort();
}
switch (opcstr[pos]) {
case 'p': srcmode = Apdi; pos++; break;
case 'P': srcmode = Aipi; pos++; break;
}
break;
case 'L':
srcmode = absl;
break;
case '#':
switch (opcstr[pos++]) {
case 'z': srcmode = imm; break;
case '0': srcmode = imm0; break;
case '1': srcmode = imm1; break;
case '2': srcmode = imm2; break;
case 'i': srcmode = immi; srcreg = (uae_s32)(uae_s8)bitval[biti];
if (CPU_EMU_SIZE < 4) {
/* Used for branch instructions */
srctype = 1;
srcgather = 1;
srcpos = bitpos[biti];
}
break;
case 'j': srcmode = immi; srcreg = bitval[bitj];
if (CPU_EMU_SIZE < 3) {
/* 1..8 for ADDQ/SUBQ and rotshi insns */
srcgather = 1;
srctype = 3;
srcpos = bitpos[bitj];
}
break;
case 'J': srcmode = immi; srcreg = bitval[bitJ];
if (CPU_EMU_SIZE < 5) {
/* 0..15 */
srcgather = 1;
srctype = 2;
srcpos = bitpos[bitJ];
}
break;
case 'k': srcmode = immi; srcreg = bitval[bitk];
if (CPU_EMU_SIZE < 3) {
srcgather = 1;
srctype = 4;
srcpos = bitpos[bitk];
}
break;
case 'K': srcmode = immi; srcreg = bitval[bitK];
if (CPU_EMU_SIZE < 5) {
/* 0..15 */
srcgather = 1;
srctype = 5;
srcpos = bitpos[bitK];
}
break;
case 'E': srcmode = immi; srcreg = bitval[bitE];
if (CPU_EMU_SIZE < 5) { // gb-- what is CPU_EMU_SIZE used for ??
/* 1..255 */
srcgather = 1;
srctype = 6;
srcpos = bitpos[bitE];
}
break;
case 'p': srcmode = immi; srcreg = bitval[bitp];
if (CPU_EMU_SIZE < 5) {
/* 0..3 */
srcgather = 1;
srctype = 7;
srcpos = bitpos[bitp];
}
break;
default: abort();
}
break;
case 'd':
srcreg = bitval[bitD];
srcmode = mode_from_mr(bitval[bitd],bitval[bitD]);
if (srcmode == am_illg)
continue;
if (CPU_EMU_SIZE < 2 &&
(srcmode == Areg || srcmode == Dreg || srcmode == Aind
|| srcmode == Ad16 || srcmode == Ad8r || srcmode == Aipi
|| srcmode == Apdi))
{
srcgather = 1; srcpos = bitpos[bitD];
}
if (opcstr[pos] == '[') {
pos++;
if (opcstr[pos] == '!') {
/* exclusion */
do {
pos++;
if (mode_from_str(opcstr+pos) == srcmode)
goto nomatch;
pos += 4;
} while (opcstr[pos] == ',');
pos++;
} else {
if (opcstr[pos+4] == '-') {
/* replacement */
if (mode_from_str(opcstr+pos) == srcmode)
srcmode = mode_from_str(opcstr+pos+5);
else
goto nomatch;
pos += 10;
} else {
/* normal */
while(mode_from_str(opcstr+pos) != srcmode) {
pos += 4;
if (opcstr[pos] == ']')
goto nomatch;
pos++;
}
while(opcstr[pos] != ']') pos++;
pos++;
break;
}
}
}
/* Some addressing modes are invalid as destination */
if (srcmode == imm || srcmode == PC16 || srcmode == PC8r)
goto nomatch;
break;
case 's':
srcreg = bitval[bitS];
srcmode = mode_from_mr(bitval[bits],bitval[bitS]);
if (srcmode == am_illg)
continue;
if (CPU_EMU_SIZE < 2 &&
(srcmode == Areg || srcmode == Dreg || srcmode == Aind
|| srcmode == Ad16 || srcmode == Ad8r || srcmode == Aipi
|| srcmode == Apdi))
{
srcgather = 1; srcpos = bitpos[bitS];
}
if (opcstr[pos] == '[') {
pos++;
if (opcstr[pos] == '!') {
/* exclusion */
do {
pos++;
if (mode_from_str(opcstr+pos) == srcmode)
goto nomatch;
pos += 4;
} while (opcstr[pos] == ',');
pos++;
} else {
if (opcstr[pos+4] == '-') {
/* replacement */
if (mode_from_str(opcstr+pos) == srcmode)
srcmode = mode_from_str(opcstr+pos+5);
else
goto nomatch;
pos += 10;
} else {
/* normal */
while(mode_from_str(opcstr+pos) != srcmode) {
pos += 4;
if (opcstr[pos] == ']')
goto nomatch;
pos++;
}
while(opcstr[pos] != ']') pos++;
pos++;
}
}
}
break;
default: abort();
}
/* safety check - might have changed */
if (srcmode != Areg && srcmode != Dreg && srcmode != Aind
&& srcmode != Ad16 && srcmode != Ad8r && srcmode != Aipi
&& srcmode != Apdi && srcmode != immi)
{
srcgather = 0;
}
if (srcmode == Areg && sz == sz_byte)
goto nomatch;
if (opcstr[pos] != ',')
goto endofline;
pos++;
/* parse the destination address */
usedst = 1;
switch (opcstr[pos++]) {
case 'D':
destmode = Dreg;
switch (opcstr[pos++]) {
case 'r': destreg = bitval[bitr]; dstgather = 1; dstpos = bitpos[bitr]; break;
case 'R': destreg = bitval[bitR]; dstgather = 1; dstpos = bitpos[bitR]; break;
default: abort();
}
if (dstpos < 0 || dstpos >= 32)
abort();
break;
case 'A':
destmode = Areg;
switch (opcstr[pos++]) {
case 'r': destreg = bitval[bitr]; dstgather = 1; dstpos = bitpos[bitr]; break;
case 'R': destreg = bitval[bitR]; dstgather = 1; dstpos = bitpos[bitR]; break;
case 'x': destreg = 0; dstgather = 0; dstpos = 0; break;
default: abort();
}
if (dstpos < 0 || dstpos >= 32)
abort();
switch (opcstr[pos]) {
case 'p': destmode = Apdi; pos++; break;
case 'P': destmode = Aipi; pos++; break;
}
break;
case 'L':
destmode = absl;
break;
case '#':
switch (opcstr[pos++]) {
case 'z': destmode = imm; break;
case '0': destmode = imm0; break;
case '1': destmode = imm1; break;
case '2': destmode = imm2; break;
case 'i': destmode = immi; destreg = (uae_s32)(uae_s8)bitval[biti]; break;
case 'j': destmode = immi; destreg = bitval[bitj]; break;
case 'J': destmode = immi; destreg = bitval[bitJ]; break;
case 'k': destmode = immi; destreg = bitval[bitk]; break;
case 'K': destmode = immi; destreg = bitval[bitK]; break;
default: abort();
}
break;
case 'd':
destreg = bitval[bitD];
destmode = mode_from_mr(bitval[bitd],bitval[bitD]);
if (destmode == am_illg)
continue;
if (CPU_EMU_SIZE < 1 &&
(destmode == Areg || destmode == Dreg || destmode == Aind
|| destmode == Ad16 || destmode == Ad8r || destmode == Aipi
|| destmode == Apdi))
{
dstgather = 1; dstpos = bitpos[bitD];
}
if (opcstr[pos] == '[') {
pos++;
if (opcstr[pos] == '!') {
/* exclusion */
do {
pos++;
if (mode_from_str(opcstr+pos) == destmode)
goto nomatch;
pos += 4;
} while (opcstr[pos] == ',');
pos++;
} else {
if (opcstr[pos+4] == '-') {
/* replacement */
if (mode_from_str(opcstr+pos) == destmode)
destmode = mode_from_str(opcstr+pos+5);
else
goto nomatch;
pos += 10;
} else {
/* normal */
while(mode_from_str(opcstr+pos) != destmode) {
pos += 4;
if (opcstr[pos] == ']')
goto nomatch;
pos++;
}
while(opcstr[pos] != ']') pos++;
pos++;
break;
}
}
}
/* Some addressing modes are invalid as destination */
if (destmode == imm || destmode == PC16 || destmode == PC8r)
goto nomatch;
break;
case 's':
destreg = bitval[bitS];
destmode = mode_from_mr(bitval[bits],bitval[bitS]);
if (destmode == am_illg)
continue;
if (CPU_EMU_SIZE < 1 &&
(destmode == Areg || destmode == Dreg || destmode == Aind
|| destmode == Ad16 || destmode == Ad8r || destmode == Aipi
|| destmode == Apdi))
{
dstgather = 1; dstpos = bitpos[bitS];
}
if (opcstr[pos] == '[') {
pos++;
if (opcstr[pos] == '!') {
/* exclusion */
do {
pos++;
if (mode_from_str(opcstr+pos) == destmode)
goto nomatch;
pos += 4;
} while (opcstr[pos] == ',');
pos++;
} else {
if (opcstr[pos+4] == '-') {
/* replacement */
if (mode_from_str(opcstr+pos) == destmode)
destmode = mode_from_str(opcstr+pos+5);
else
goto nomatch;
pos += 10;
} else {
/* normal */
while(mode_from_str(opcstr+pos) != destmode) {
pos += 4;
if (opcstr[pos] == ']')
goto nomatch;
pos++;
}
while(opcstr[pos] != ']') pos++;
pos++;
}
}
}
break;
default: abort();
}
/* safety check - might have changed */
if (destmode != Areg && destmode != Dreg && destmode != Aind
&& destmode != Ad16 && destmode != Ad8r && destmode != Aipi
&& destmode != Apdi)
{
dstgather = 0;
}
if (destmode == Areg && sz == sz_byte)
goto nomatch;
#if 0
if (sz == sz_byte && (destmode == Aipi || destmode == Apdi)) {
dstgather = 0;
}
#endif
endofline:
/* now, we have a match */
if (table68k[opc].mnemo != i_ILLG)
fprintf(stderr, "Double match: %x: %s\n", opc, opcstr);
if (find == -1) {
for (find = 0;; find++) {
if (strcmp(mnemonic, lookuptab[find].name) == 0) {
table68k[opc].mnemo = lookuptab[find].mnemo;
break;
}
if (strlen(lookuptab[find].name) == 0) abort();
}
}
else {
table68k[opc].mnemo = lookuptab[find].mnemo;
}
table68k[opc].cc = bitval[bitc];
if (table68k[opc].mnemo == i_BTST
|| table68k[opc].mnemo == i_BSET
|| table68k[opc].mnemo == i_BCLR
|| table68k[opc].mnemo == i_BCHG)
{
sz = destmode == Dreg ? sz_long : sz_byte;
}
table68k[opc].size = sz;
table68k[opc].sreg = srcreg;
table68k[opc].dreg = destreg;
table68k[opc].smode = srcmode;
table68k[opc].dmode = destmode;
table68k[opc].spos = srcgather ? srcpos : -1;
table68k[opc].dpos = dstgather ? dstpos : -1;
table68k[opc].suse = usesrc;
table68k[opc].duse = usedst;
table68k[opc].stype = srctype;
table68k[opc].plev = id.plevel;
table68k[opc].clev = id.cpulevel;
#if 0
for (i = 0; i < 5; i++) {
table68k[opc].flaginfo[i].flagset = id.flaginfo[i].flagset;
table68k[opc].flaginfo[i].flaguse = id.flaginfo[i].flaguse;
}
#endif
// Fix flags used information for Scc, Bcc, TRAPcc, DBcc instructions
if ( table68k[opc].mnemo == i_Scc
|| table68k[opc].mnemo == i_Bcc
|| table68k[opc].mnemo == i_DBcc
|| table68k[opc].mnemo == i_TRAPcc
) {
switch (table68k[opc].cc) {
// CC mask: XNZVC
// 8421
case 0: flags_used = 0x00; break; /* T */
case 1: flags_used = 0x00; break; /* F */
case 2: flags_used = 0x05; break; /* HI */
case 3: flags_used = 0x05; break; /* LS */
case 4: flags_used = 0x01; break; /* CC */
case 5: flags_used = 0x01; break; /* CS */
case 6: flags_used = 0x04; break; /* NE */
case 7: flags_used = 0x04; break; /* EQ */
case 8: flags_used = 0x02; break; /* VC */
case 9: flags_used = 0x02; break; /* VS */
case 10:flags_used = 0x08; break; /* PL */
case 11:flags_used = 0x08; break; /* MI */
case 12:flags_used = 0x0A; break; /* GE */
case 13:flags_used = 0x0A; break; /* LT */
case 14:flags_used = 0x0E; break; /* GT */
case 15:flags_used = 0x0E; break; /* LE */
}
}
#if 1
/* gb-- flagdead and flaglive would not have correct information */
table68k[opc].flagdead = flags_set;
table68k[opc].flaglive = flags_used;
#else
table68k[opc].flagdead = flagdead;
table68k[opc].flaglive = flaglive;
#endif
table68k[opc].cflow = cflow;
nomatch:
/* FOO! */;
}
