int _tmain(int argc, _TCHAR* argv[]) { if (bxsi(0x1111, 0x2222) != 0x3333) return 1; if (bxdi(0x1212, 0x2222) != 0x3434) return 2; if (bpsi(0x1234, 0x5678) != 0x68ac) return 3; if (bpdi(0xf000, 0x1000) != 0x0000) return 4; if (si(0xcafe) != 0xcafe) return 5; if (di(0xdead) != 0xdead) return 5; if (disp16() != 0xeeee) return 6; if (bx(0x1) != 0x1) return 7; if (bxsidisp8(0x1111, 0x2222) != 0x3334) return 8; if (bxsidisp16(0x1111, 0x2222) != 0x3333) return 16; if (reg(0xf0f0) != 0xf0f0) return 32; return 0; }
srcdest decode_bit (int destcode) { srcdest sd; int addr = 0; static const char *dc_names[] = { "r0", "r1", "r2", "r3", "a0", "a1", "[a0]", "[a1]", "disp8[a0]", "disp8[a1]", "disp8[sb]", "disp8[fb]", "disp16[a0]", "disp16[a1]", "disp16[sb]", "abs16" }; if (trace) { const char *the_bits = bits (destcode, 4); printf ("decode: %s : %s\n", the_bits, dc_names[destcode]); } switch (destcode) { case 0: sd.u.reg = r0; break; case 1: sd.u.reg = r1; break; case 2: sd.u.reg = r2; break; case 3: sd.u.reg = r3; break; case 4: sd.u.reg = a0; break; case 5: sd.u.reg = a1; break; case 6: addr = get_reg (a0); break; case 7: addr = get_reg (a1); break; case 8: addr = get_reg (a0) + disp8 (); break; case 9: addr = get_reg (a1) + disp8 (); break; case 10: addr = get_reg (sb) * 8 + disp8 (); break; case 11: addr = get_reg (fb) * 8 + sign_ext (disp8 (), 8); break; case 12: addr = get_reg (a0) + disp16 (); break; case 13: addr = get_reg (a1) + disp16 (); break; case 14: addr = get_reg (sb) + disp16 (); break; case 15: addr = disp16 (); break; } if (destcode < 6) { int d = disp8 (); sd.mem = 0; sd.mask = 1 << (d & 0x0f); } else { addr &= addr_mask; sd.mem = 1; sd.mask = 1 << (addr & 7); sd.u.addr = addr >> 3; } return sd; }
static srcdest decode_sd23 (int bbb, int bb, int bytes, int ind, int add) { srcdest sd; int code = (bbb << 2) | bb; if (code >= sizeof (modes23) / sizeof (modes23[0])) abort (); if (trace) { char *b1 = ""; char *b2 = ""; char ad[30]; if (ind) { b1 = "["; b2 = "]"; } if (add) sprintf (ad, "%+d", add); else ad[0] = 0; if (!the_bits) the_bits = bits (code, 4); printf ("decode: %s (%d) : %s%s%s%s\n", the_bits, code, b1, modes23[code].name, ad, b2); the_bits = 0; } sd.bytes = bytes; sd.mem = modes23[code].is_memory; if (sd.mem) { if (modes23[code].w_regno == mem) sd.u.addr = 0; else sd.u.addr = get_reg (modes23[code].w_regno); switch (modes23[code].disp_bytes) { case 1: sd.u.addr += disp8 (); break; case 2: sd.u.addr += disp16 (); break; case -1: sd.u.addr += sign_ext (disp8 (), 8); break; case -2: sd.u.addr += sign_ext (disp16 (), 16); break; case 3: sd.u.addr += disp24 (); break; default: break; } if (add) sd.u.addr += add; if (ind) sd.u.addr = mem_get_si (sd.u.addr & membus_mask); sd.u.addr &= membus_mask; } else { sd.u.reg = (bytes > 1) ? modes23[code].w_regno : modes23[code].b_regno; if (bytes == 3 || bytes == 4) { switch (sd.u.reg) { case r0: sd.u.reg = r2r0; break; case r1: sd.u.reg = r3r1; break; case r2: abort (); case r3: abort (); default:; } } } return sd; }
srcdest decode_jumpdest (int destcode, int w) { srcdest sd; sd.bytes = w ? 2 : 3; sd.mem = (destcode >= 6) ? 1 : 0; static const char *dc_wnames[16] = { "r0", "r1", "r2", "r3", "a0", "a1", "[a0]", "[a1]", "disp8[a0]", "disp8[a1]", "disp8[sb]", "disp8[fb]", "disp20[a0]", "disp20[a1]", "disp16[sb]", "abs16" }; static const char *dc_anames[4] = { "r0l", "r0h", "r1l", "r1h" }; if (trace) { const char *n = dc_wnames[destcode]; if (w == 0 && destcode <= 3) n = dc_anames[destcode]; if (!the_bits) the_bits = bits (destcode, 4); printf ("decode: %s : %s\n", the_bits, n); the_bits = 0; } switch (destcode) { case 0x0: sd.u.reg = w ? r0 : r2r0; break; case 0x1: sd.u.reg = w ? r1 : r2r0; break; case 0x2: sd.u.reg = w ? r2 : r3r1; break; case 0x3: sd.u.reg = w ? r3 : r3r1; break; case 0x4: sd.u.reg = w ? a0 : a1a0; break; case 0x5: sd.u.reg = w ? a1 : a1a0; break; case 0x6: sd.u.addr = get_reg (a0); break; case 0x7: sd.u.addr = get_reg (a1); break; case 0x8: sd.u.addr = get_reg (a0) + disp8 (); break; case 0x9: sd.u.addr = get_reg (a1) + disp8 (); break; case 0xa: sd.u.addr = get_reg (sb) + disp8 (); break; case 0xb: sd.u.addr = get_reg (fb) + sign_ext (disp8 (), 8); break; case 0xc: sd.u.addr = get_reg (a0) + disp20 (); break; case 0xd: sd.u.addr = get_reg (a1) + disp20 (); break; case 0xe: sd.u.addr = get_reg (sb) + disp16 (); break; case 0xf: sd.u.addr = disp16 (); break; default: abort (); } if (sd.mem) sd.u.addr &= addr_mask; return sd; }