diff options
Diffstat (limited to 'src/devices/cpu/m6809/knmidasm.c')
-rw-r--r-- | src/devices/cpu/m6809/knmidasm.c | 1877 |
1 files changed, 1877 insertions, 0 deletions
diff --git a/src/devices/cpu/m6809/knmidasm.c b/src/devices/cpu/m6809/knmidasm.c new file mode 100644 index 00000000000..5c325e81718 --- /dev/null +++ b/src/devices/cpu/m6809/knmidasm.c @@ -0,0 +1,1877 @@ +// license:BSD-3-Clause +// copyright-holders:Nathan Woods +#include "emu.h" +#include "debugger.h" +#include "konami.h" + +#ifndef TRUE +#define TRUE -1 +#define FALSE 0 +#endif + +/* + +0x08 leax indexed +0x09 leay indexed (not confirmed) +0x0a leau indexed +0x0b leas indexed (not confirmed) + +0x0c pushs xx +0x0d pushu xx (not confirmed) +0x0e pulls xx +0x0f pulls xx (not confirmed) + +0x10 lda xx +0x11 ldb xx +0x12 lda indexed +0x13 ldb indexed + +0x14 adda xx +0x15 addb xx (not confirmed) +0x16 adda indexed (not confirmed) +0x17 addb indexed + +0x18 adca xx +0x19 adcb xx (not confirmed) +0x1a adca indexed (not confirmed) +0x1b adcb indexed (not confirmed) + +0x1c suba xx +0x1d subb xx +0x1e suba indexed +0x1f subb indexed + +0x20 sbca xx +0x21 sbcb xx +0x22 sbca indexed +0x23 sbcb indexed + +0x24 anda xx +0x25 andb xx +0x26 anda indexed +0x27 andb indexed + +0x28 bita xx +0x29 bitb xx +0x2a bita indexed +0x2b bitb indexed + +0x2c eora xx +0x2d eorb xx +0x2e eora indexed +0x2f eorb indexed + +0x30 ora xx +0x31 orb xx +0x32 ora indexed +0x33 orb indexed + +0x34 cmpa xx +0x35 cmpb xx +0x36 cmpa indexed +0x37 cmpb indexed + +CUSTOM OPCODE: Set Address lines 16-23 +-------------------------------------- +0x38 setlines xx +0x39 setlines indexed + +The eight bits taken as parameter set address lines 16 to 23. + + +0x3a sta indexed +0x3b stb indexed +0x3c andcc +0x3d orcc + +0x3e exg xx +0x3f tfr xx + +0x40 ldd xx xx +0x41 ldd indexed +0x42 ldx xx xx +0x43 ldx indexed +0x44 ldy xx xx +0x45 ldy indexed (not confirmed) +0x46 ldu xx xx +0x47 ldu indexed +0x48 lds xx xx +0x49 lds indexed (not confirmed) + +0x4a cmpd xx xx +0x4b cmpd indexed +0x4c cmpx xx xx +0x4d cmpx indexed +0x4e cmpy xx xx (not confirmed) +0x4f cmpy indexed (not confirmed) +0x50 cmpu xx xx (not confirmed) +0x51 cmpu indexed (not confirmed) +0x52 cmps xx xx (not confirmed) +0x53 cmps indexed (not confirmed) + +0x54 addd xx xx +0x55 addd indexed (not confirmed) +0x56 subd xx xx +0x57 subd indexed (not confirmed) + +0x58 std indexed +0x59 stx indexed +0x5a sty indexed +0x5b stu indexed +0x5c sts indexed (not confirmed) + + +BRANCH OPCODE TABLE : +--------------------- + +Opcode M6809 Konami +BRA 20 60 +BRN 21 70 +BHI 22 61 +BLS 23 71 +BCC 24 62 +BCS 25 72 +BNE 26 63 +BEQ 27 73 +BVC 28 64 +BVS 29 74 +BPL 2a 65 +BMI 2b 75 +BGE 2c 66 +BLT 2d 76 +BGT 2e 67 +BLE 2f 77 + +Long versions of the branchs are the number + 8. + +0x80 clra +0x81 clrb +0x82 clr indexed + +0x83 coma +0x84 comb +0x85 com indexed + +0x86 nega (not confirmed) +0x87 negb (not confirmed) +0x88 neg indexed (not confirmed) + +0x89 inca +0x8a incb (not confirmed) +0x8b inc indexed + +0x8c deca +0x8d decb +0x8e dec indexed + +0x8f rts + +0x90 tsta (not confirmed) +0x91 tstb (not confirmed) +0x92 tst indexed (not confirmed) + +0x93 lsra +0x94 lsrb +0x95 lsr indexed + +0x96 rora +0x97 rorb +0x98 ror indexed + +0x99 asra +0x9a asrb +0x9b asr indexed + +0x9c asla +0x9d aslb +0x9e asl indexed + +0x9f rti + +0xa0 rola +0xa1 rolb +0xa2 rol indexed + +0xa3 lsrw indexed ( not confirmed ) +0xa4 rorw indexed ( not confirmed ) +0xa5 asrw indexed ( not confirmed ) +0xa6 aslw indexed ( not confirmed ) +0xa7 rolw indexed ( not confirmed ) + +0xa8 jmp indexed +0xa9 jsr indexed +0xaa bsr xx +0xab lbsr xx xx +0xac decb,jnz xx +0xad decx,jnz xx +0xae nop + +0xb0 abx +0xb1 daa +0xb2 sex + +0xb3 mul + +0xb4 lmul x:y = x * y + +0xb5 divx x = ( x / b ), b = ( x % b ) + +CUSTOM OPCODE: BlockMove (y,x,u): +--------------------------------- +0xb6 bmove y,x,u + +y = pointer to source address +x = pointer to destination address +u = bytes to move + +One byte is copied at a time and x and y get incremented for each access. + +CUSTOM OPCODE: Move (y,x,u): +--------------------------------- +0xb7 move y,x,u + +y = pointer to source address +x = pointer to destination address +u = counter + +Copy ONE byte, increment x and y, decrement u. + +0xb8 lsrd xx +0xb9 lsrd indexed +0xba rord xx ( not confirmed ) +0xbb rord indexed ( not confirmed ) +0xbc asrd xx ( not confirmed ) +0xbd asrd indexed ( not confirmed ) +0xbe asld xx +0xbf asld indexed ( not confirmed ) +0xc0 rold xx ( not confirmed ) +0xc1 rold indexed ( not confirmed ) + +0xc2 clrd +0xc3 clrw indexed ( clears an entire word ) ( not confirmed ) + +0xc4 negd (not confirmed ) +0xc5 negw indexed + +0xc6 incd (not confirmed ) +0xc7 incw indexed + +0xc8 decd (not confirmed ) +0xc9 decw indexed + +0xca tstd +0xcb tstw indexed + +0xcc absa +0xcd absb +0xce absd + +CUSTOM OPCODE: BlockSet (a,x,u): +--------------------------------- +0xcf bset a,x,u + +a = source data +x = pointer to destination address +u = bytes to move + +One byte is copied at a time and x get incremented for each access. + +CUSTOM OPCODE: BlockSet (d,x,u): (not confirmed) +-------------------------------- +0xd0 bset d,x,u + +d = source data +x = pointer to destination address +u = bytes to move/2 + +Two bytes are copied at a time and x get incremented twice for each access. + +*/ + +static unsigned byte_count; +static unsigned local_pc; +static unsigned flags; + +static const unsigned char *opram_ptr; + +static unsigned char get_next_byte( void ) { + return opram_ptr[byte_count++]; +} + +/* Table for indexed operations */ +static const char index_reg[8][3] = { + "?", /* 0 - extended mode */ + "?", /* 1 */ + "x", /* 2 */ + "y", /* 3 */ + "?", /* 4 - direct page */ + "u", /* 5 */ + "s", /* 6 */ + "pc" /* 7 - pc */ +}; + +/* Table for tfr/exg operations */ +static const char tfrexg_reg[8][3] = { + "a", /* 0 */ + "b", /* 1 */ + "x", /* 2 */ + "y", /* 3 */ + "s", /* 4 */ + "u", /* 5 */ + "?", /* 6 */ + "?", /* 7 */ +}; + +/* Table for stack S operations */ +static const char stack_reg_s[8][3] = { + "cc", + "a", + "b", + "dp", + "x", + "y", + "u", + "pc" +}; + +/* Table for stack U operations */ +static const char stack_reg_u[8][3] = { + "cc", + "a", + "b", + "dp", + "x", + "y", + "s", + "pc" +}; + +static void calc_indexed( unsigned char mode, char *buf ) { + char buf2[30]; + int idx, type; + + idx = ( mode >> 4 ) & 7; + type = mode & 0x0f; + + /* special modes */ + if ( mode & 0x80 ) { + if ( type & 8 ) { /* indirect */ + switch ( type & 7 ) { + case 0x00: /* register a */ + sprintf( buf2, "[a,%s]", index_reg[idx] ); + break; + + case 0x01: /* register b */ + sprintf( buf2, "[b,%s]", index_reg[idx] ); + break; + + case 0x04: /* direct - mode */ + sprintf( buf2, "[$%02x]", get_next_byte() ); + break; + + case 0x07: /* register d */ + sprintf( buf2, "[d,%s]", index_reg[idx] ); + break; + + default: + sprintf( buf2, "[?,%s]", index_reg[idx] ); + break; + } + } else { + switch ( type & 7 ) { + case 0x00: /* register a */ + sprintf( buf2, "a,%s", index_reg[idx] ); + break; + + case 0x01: /* register b */ + sprintf( buf2, "b,%s", index_reg[idx] ); + break; + + case 0x04: /* direct - mode */ + sprintf( buf2, "$%02x", get_next_byte() ); + break; + + case 0x07: /* register d */ + sprintf( buf2, "d,%s", index_reg[idx] ); + break; + + default: + sprintf( buf2, "????,%s", index_reg[idx] ); + break; + } + } + } else { + if ( type & 8 ) { /* indirect */ + switch ( type & 7 ) { + case 0: /* auto increment */ + sprintf( buf2, "[,%s+]", index_reg[idx] ); + break; + + case 1: /* auto increment double */ + sprintf( buf2, "[,%s++]", index_reg[idx] ); + break; + + case 2: /* auto decrement */ + sprintf( buf2, "[,-%s]", index_reg[idx] ); + break; + + case 3: /* auto decrement double */ + sprintf( buf2, "[,--%s]", index_reg[idx] ); + break; + + case 4: /* post byte offset */ + { + int val = get_next_byte(); + + if ( val & 0x80 ) + sprintf( buf2, "[#$-%02x,%s]", 0x100 - val, index_reg[idx] ); + else + sprintf( buf2, "[#$%02x,%s]", val, index_reg[idx] ); + } + break; + + case 5: /* post word offset */ + { + int val = get_next_byte() << 8; + + val |= get_next_byte(); + + if ( val & 0x8000 ) + sprintf( buf2, "[#$-%04x,%s]", 0x10000 - val, index_reg[idx] ); + else + sprintf( buf2, "[#$%04x,%s]", val, index_reg[idx] ); + } + break; + + case 6: /* simple */ + sprintf( buf2, "[,%s]", index_reg[idx] ); + break; + + case 7: /* extended */ + { + int val = get_next_byte() << 8; + + val |= get_next_byte(); + + sprintf( buf2, "[$%04x]", val ); + } + break; + } + } else { + switch ( type & 7 ) { + case 0: /* auto increment */ + sprintf( buf2, ",%s+", index_reg[idx] ); + break; + + case 1: /* auto increment double */ + sprintf( buf2, ",%s++", index_reg[idx] ); + break; + + case 2: /* auto decrement */ + sprintf( buf2, ",-%s", index_reg[idx] ); + break; + + case 3: /* auto decrement double */ + sprintf( buf2, ",--%s", index_reg[idx] ); + break; + + case 4: /* post byte offset */ + { + int val = get_next_byte(); + + if ( val & 0x80 ) + sprintf( buf2, "#$-%02x,%s", 0x100 - val , index_reg[idx] ); + else + sprintf( buf2, "#$%02x,%s", val, index_reg[idx] ); + } + break; + + case 5: /* post word offset */ + { + int val = get_next_byte() << 8; + + val |= get_next_byte(); + + if ( val & 0x8000 ) + sprintf( buf2, "#$-%04x,%s", 0x10000 - val, index_reg[idx] ); + else + sprintf( buf2, "#$%04x,%s", val, index_reg[idx] ); + } + break; + + case 6: /* simple */ + sprintf( buf2, ",%s", index_reg[idx] ); + break; + + case 7: /* extended */ + { + int val = get_next_byte() << 8; + + val |= get_next_byte(); + + sprintf( buf2, "$%04x", val ); + } + break; + + } + } + } + + strcat( buf, buf2 ); +} + +static void do_relative( char *buf ) { + char buf2[30]; + signed char offs = ( signed char )get_next_byte(); + + sprintf( buf2, "$%04x (%d)", local_pc + byte_count + offs, (int)offs ); + + strcat( buf, buf2 ); +} + +static void do_relative_word( char *buf ) { + char buf2[30]; + signed short offs; + int val = get_next_byte() << 8; + + val |= get_next_byte(); + + offs = ( signed short )val; + + sprintf( buf2, "$%04x (%d)", local_pc + byte_count + offs, (int)offs ); + + strcat( buf, buf2 ); +} + +static void do_addressing( char *buf ) { + unsigned char mode = get_next_byte(); + + calc_indexed( mode, buf ); +} + +/********************************************************************************* + + Opcodes + +*********************************************************************************/ + +static void illegal( char *buf ) { + sprintf( buf, "illegal/unknown " ); + +} + +static void leax( char *buf ) { + sprintf( buf, "leax " ); + do_addressing( buf ); +} + +static void leay( char *buf ) { + sprintf( buf, "leay " ); + do_addressing( buf ); +} + +static void leau( char *buf ) { + sprintf( buf, "leau " ); + do_addressing( buf ); +} + +static void leas( char *buf ) { + sprintf( buf, "leas " ); + do_addressing( buf ); +} + +static void lda( char *buf ) { + sprintf( buf, "lda #$%02x", get_next_byte() ); +} + +static void ldb( char *buf ) { + sprintf( buf, "ldb #$%02x", get_next_byte() ); +} + +static void lda2( char *buf ) { + sprintf( buf, "lda " ); + do_addressing( buf ); +} + +static void ldb2( char *buf ) { + sprintf( buf, "ldb " ); + do_addressing( buf ); +} + +static void adda( char *buf ) { + sprintf( buf, "adda #$%02x", get_next_byte() ); +} + +static void addb( char *buf ) { + sprintf( buf, "addb #$%02x", get_next_byte() ); +} + +static void adda2( char *buf ) { + sprintf( buf, "adda " ); + do_addressing( buf ); +} + +static void addb2( char *buf ) { + sprintf( buf, "addb " ); + do_addressing( buf ); +} + +static void suba( char *buf ) { + sprintf( buf, "suba #$%02x", get_next_byte() ); +} + +static void subb( char *buf ) { + sprintf( buf, "subb #$%02x", get_next_byte() ); +} + +static void suba2( char *buf ) { + sprintf( buf, "suba " ); + do_addressing( buf ); +} + +static void subb2( char *buf ) { + sprintf( buf, "subb " ); + do_addressing( buf ); +} + +static void sbca( char *buf ) { + sprintf( buf, "sbca #$%02x", get_next_byte() ); +} + +static void sbcb( char *buf ) { + sprintf( buf, "sbcb #$%02x", get_next_byte() ); +} + +static void sbca2( char *buf ) { + sprintf( buf, "sbca " ); + do_addressing( buf ); +} + +static void sbcb2( char *buf ) { + sprintf( buf, "sbcb " ); + do_addressing( buf ); +} + +static void adca( char *buf ) { + sprintf( buf, "adca #$%02x", get_next_byte() ); +} + +static void adca2( char *buf ) { + sprintf( buf, "adca " ); + do_addressing( buf ); +} + +static void adcb2( char *buf ) { + sprintf( buf, "adcb " ); + do_addressing( buf ); +} + +static void adcb( char *buf ) { + sprintf( buf, "adcb #$%02x", get_next_byte() ); +} + +static void anda( char *buf ) { + sprintf( buf, "anda #$%02x", get_next_byte() ); +} + +static void andb( char *buf ) { + sprintf( buf, "andb #$%02x", get_next_byte() ); +} + +static void anda2( char *buf ) { + sprintf( buf, "anda " ); + do_addressing( buf ); +} + +static void andb2( char *buf ) { + sprintf( buf, "andb " ); + do_addressing( buf ); +} + +static void bita( char *buf ) { + sprintf( buf, "bita #$%02x", get_next_byte() ); +} + +static void bitb( char *buf ) { + sprintf( buf, "bitb #$%02x", get_next_byte() ); +} + +static void bita2( char *buf ) { + sprintf( buf, "bita " ); + do_addressing( buf ); +} + +static void bitb2( char *buf ) { + sprintf( buf, "bitb " ); + do_addressing( buf ); +} + +static void eora( char *buf ) { + sprintf( buf, "eora #$%02x", get_next_byte() ); +} + +static void eorb( char *buf ) { + sprintf( buf, "eorb #$%02x", get_next_byte() ); +} + +static void eora2( char *buf ) { + sprintf( buf, "eora " ); + do_addressing( buf ); +} + +static void eorb2( char *buf ) { + sprintf( buf, "eorb " ); + do_addressing( buf ); +} + +static void ora( char *buf ) { + sprintf( buf, "ora #$%02x", get_next_byte() ); +} + +static void orb( char *buf ) { + sprintf( buf, "orb #$%02x", get_next_byte() ); +} + +static void ora2( char *buf ) { + sprintf( buf, "ora " ); + do_addressing( buf ); +} + +static void orb2( char *buf ) { + sprintf( buf, "orb " ); + do_addressing( buf ); +} + +static void cmpa( char *buf ) { + sprintf( buf, "cmpa #$%02x", get_next_byte() ); +} + +static void cmpb( char *buf ) { + sprintf( buf, "cmpb #$%02x", get_next_byte() ); +} + +static void cmpa2( char *buf ) { + sprintf( buf, "cmpa " ); + do_addressing( buf ); +} + +static void cmpb2( char *buf ) { + sprintf( buf, "cmpb " ); + do_addressing( buf ); +} + +static void setlines( char *buf ) { + sprintf( buf, "setlines #$%02x", get_next_byte() ); +} + +static void setlines2( char *buf ) { + sprintf( buf, "setlines " ); + do_addressing( buf ); +} + +static void sta2( char *buf ) { + sprintf( buf, "sta " ); + do_addressing( buf ); +} + +static void stb2( char *buf ) { + sprintf( buf, "stb " ); + do_addressing( buf ); +} + +static void ldd( char *buf ) { + int val = get_next_byte() << 8; + + val |= get_next_byte(); + + sprintf( buf, "ldd #$%04x", val ); +} + +static void ldd2( char *buf ) { + sprintf( buf, "ldd " ); + do_addressing( buf ); +} + +static void ldx( char *buf ) { + int val = get_next_byte() << 8; + + val |= get_next_byte(); + + sprintf( buf, "ldx #$%04x", val ); +} + +static void ldx2( char *buf ) { + sprintf( buf, "ldx " ); + do_addressing( buf ); +} + +static void ldy( char *buf ) { + int val = get_next_byte() << 8; + + val |= get_next_byte(); + + sprintf( buf, "ldy #$%04x", val ); +} + +static void ldy2( char *buf ) { + sprintf( buf, "ldy " ); + do_addressing( buf ); +} + +static void ldu( char *buf ) { + int val = get_next_byte() << 8; + + val |= get_next_byte(); + + sprintf( buf, "ldu #$%04x", val ); +} + +static void ldu2( char *buf ) { + sprintf( buf, "ldu " ); + do_addressing( buf ); +} + +static void lds( char *buf ) { + int val = get_next_byte() << 8; + + val |= get_next_byte(); + + sprintf( buf, "lds #$%04x", val ); +} + +static void lds2( char *buf ) { + sprintf( buf, "lds " ); + do_addressing( buf ); +} + +static void cmpd( char *buf ) { + int val = get_next_byte() << 8; + + val |= get_next_byte(); + + sprintf( buf, "cmpd #$%04x", val ); +} + +static void cmpd2( char *buf ) { + sprintf( buf, "cmpd " ); + do_addressing( buf ); +} + +static void cmpx( char *buf ) { + int val = get_next_byte() << 8; + + val |= get_next_byte(); + + sprintf( buf, "cmpx #$%04x", val ); +} + +static void cmpx2( char *buf ) { + sprintf( buf, "cmpx " ); + do_addressing( buf ); +} + +static void cmpy( char *buf ) { + int val = get_next_byte() << 8; + + val |= get_next_byte(); + + sprintf( buf, "cmpy #$%04x", val ); +} + +static void cmpy2( char *buf ) { + sprintf( buf, "cmpy " ); + do_addressing( buf ); +} + +static void cmpu( char *buf ) { + int val = get_next_byte() << 8; + + val |= get_next_byte(); + + sprintf( buf, "cmpu #$%04x", val ); +} + +static void cmpu2( char *buf ) { + sprintf( buf, "cmpu " ); + do_addressing( buf ); +} + +static void cmps( char *buf ) { + int val = get_next_byte() << 8; + + val |= get_next_byte(); + + sprintf( buf, "cmps #$%04x", val ); +} + +static void cmps2( char *buf ) { + sprintf( buf, "cmps " ); + do_addressing( buf ); +} + +static void addd2( char *buf ) { + sprintf( buf, "addd " ); + do_addressing( buf ); +} + +static void subd2( char *buf ) { + sprintf( buf, "subd " ); + do_addressing( buf ); +} + +static void std2( char *buf ) { + sprintf( buf, "std " ); + do_addressing( buf ); +} + +static void stx2( char *buf ) { + sprintf( buf, "stx " ); + do_addressing( buf ); +} + +static void sty2( char *buf ) { + sprintf( buf, "sty " ); + do_addressing( buf ); +} + +static void stu2( char *buf ) { + sprintf( buf, "stu " ); + do_addressing( buf ); +} + +static void sts2( char *buf ) { + sprintf( buf, "sts " ); + do_addressing( buf ); +} + +static void bra( char *buf ) { + sprintf( buf, "bra " ); + do_relative( buf ); +} + +static void lbra( char *buf ) { + sprintf( buf, "lbra " ); + do_relative_word( buf ); +} + +static void brn( char *buf ) { + sprintf( buf, "brn " ); + do_relative( buf ); +} + +static void lbrn( char *buf ) { + sprintf( buf, "lbrn " ); + do_relative_word( buf ); +} + +static void bhi( char *buf ) { + sprintf( buf, "bhi " ); + do_relative( buf ); +} + +static void lbhi( char *buf ) { + sprintf( buf, "lbhi " ); + do_relative_word( buf ); +} + +static void bls( char *buf ) { + sprintf( buf, "bls " ); + do_relative( buf ); +} + +static void lbls( char *buf ) { + sprintf( buf, "lbls " ); + do_relative_word( buf ); +} + +static void bcc( char *buf ) { + sprintf( buf, "bcc " ); + do_relative( buf ); +} + +static void lbcc( char *buf ) { + sprintf( buf, "lbcc " ); + do_relative_word( buf ); +} + +static void bcs( char *buf ) { + sprintf( buf, "bcs " ); + do_relative( buf ); +} + +static void lbcs( char *buf ) { + sprintf( buf, "lbcs " ); + do_relative_word( buf ); +} + +static void bne( char *buf ) { + sprintf( buf, "bne " ); + do_relative( buf ); +} + +static void lbne( char *buf ) { + sprintf( buf, "lbne " ); + do_relative_word( buf ); +} + +static void beq( char *buf ) { + sprintf( buf, "beq " ); + do_relative( buf ); +} + +static void lbeq( char *buf ) { + sprintf( buf, "lbeq " ); + do_relative_word( buf ); +} + +static void bvc( char *buf ) { + sprintf( buf, "bvc " ); + do_relative( buf ); +} + +static void lbvc( char *buf ) { + sprintf( buf, "lbvc " ); + do_relative_word( buf ); +} + +static void bvs( char *buf ) { + sprintf( buf, "bvs " ); + do_relative( buf ); +} + +static void lbvs( char *buf ) { + sprintf( buf, "lbvs " ); + do_relative_word( buf ); +} + +static void bpl( char *buf ) { + sprintf( buf, "bpl " ); + do_relative( buf ); +} + +static void lbpl( char *buf ) { + sprintf( buf, "lbpl " ); + do_relative_word( buf ); +} + +static void bmi( char *buf ) { + sprintf( buf, "bmi " ); + do_relative( buf ); +} + +static void lbmi( char *buf ) { + sprintf( buf, "lbmi " ); + do_relative_word( buf ); +} + +static void bge( char *buf ) { + sprintf( buf, "bge " ); + do_relative( buf ); +} + +static void lbge( char *buf ) { + sprintf( buf, "lbge " ); + do_relative_word( buf ); +} + +static void blt( char *buf ) { + sprintf( buf, "blt " ); + do_relative( buf ); +} + +static void lblt( char *buf ) { + sprintf( buf, "lblt " ); + do_relative_word( buf ); +} + +static void bgt( char *buf ) { + sprintf( buf, "bgt " ); + do_relative( buf ); +} + +static void lbgt( char *buf ) { + sprintf( buf, "lbgt " ); + do_relative_word( buf ); +} + +static void ble( char *buf ) { + sprintf( buf, "ble " ); + do_relative( buf ); +} + +static void lble( char *buf ) { + sprintf( buf, "lble " ); + do_relative_word( buf ); +} + +static void clra( char *buf ) { + sprintf( buf, "clra" ); +} + +static void clrb( char *buf ) { + sprintf( buf, "clrb" ); +} + +static void clrd( char *buf ) { + sprintf( buf, "clrd" ); +} + +static void clrw( char *buf ) { + sprintf( buf, "clrw " ); + do_addressing( buf ); +} + +static void negd( char *buf ) { + sprintf( buf, "negd" ); +} + +static void negw( char *buf ) { + sprintf( buf, "negw" ); + do_addressing( buf ); +} + +static void incd( char *buf ) { + sprintf( buf, "incd" ); +} + +static void incw( char *buf ) { + sprintf( buf, "incw " ); + do_addressing( buf ); +} + +static void decd( char *buf ) { + sprintf( buf, "decd" ); +} + +static void decw( char *buf ) { + sprintf( buf, "decw " ); + do_addressing( buf ); +} + +static void tstd( char *buf ) { + sprintf( buf, "tstd " ); +} + +static void tstw( char *buf ) { + sprintf( buf, "tstw " ); + do_addressing( buf ); +} + +static void clr2( char *buf ) { + sprintf( buf, "clr " ); + do_addressing( buf ); +} + +static void coma( char *buf ) { + sprintf( buf, "coma" ); +} + +static void comb( char *buf ) { + sprintf( buf, "comb" ); +} + +static void com2( char *buf ) { + sprintf( buf, "com " ); + do_addressing( buf ); +} + +static void nega( char *buf ) { + sprintf( buf, "nega" ); +} + +static void negb( char *buf ) { + sprintf( buf, "negb" ); +} + +static void neg2( char *buf ) { + sprintf( buf, "neg " ); + do_addressing( buf ); +} + +static void inca( char *buf ) { + sprintf( buf, "inca" ); +} + +static void incb( char *buf ) { + sprintf( buf, "incb" ); +} + +static void inc2( char *buf ) { + sprintf( buf, "inc " ); + do_addressing( buf ); +} + +static void deca( char *buf ) { + sprintf( buf, "deca" ); +} + +static void decb( char *buf ) { + sprintf( buf, "decb" ); +} + +static void dec2( char *buf ) { + sprintf( buf, "dec " ); + do_addressing( buf ); +} + +static void rts( char *buf ) { + sprintf( buf, "rts" ); + flags = DASMFLAG_STEP_OUT; +} + +static void asla( char *buf ) { + sprintf( buf, "asla" ); +} + +static void aslb( char *buf ) { + sprintf( buf, "aslb" ); +} + +static void asl2( char *buf ) { + sprintf( buf, "asl " ); + do_addressing( buf ); +} + +static void rora( char *buf ) { + sprintf( buf, "rora" ); +} + +static void rorb( char *buf ) { + sprintf( buf, "rorb" ); +} + +static void ror2( char *buf ) { + sprintf( buf, "ror " ); + do_addressing( buf ); +} + +static void rti( char *buf ) { + sprintf( buf, "rti" ); + flags = DASMFLAG_STEP_OUT; +} + +static void jsr2( char *buf ) { + sprintf( buf, "jsr " ); + do_addressing( buf ); + flags = DASMFLAG_STEP_OVER; +} + +static void jmp2( char *buf ) { + sprintf( buf, "jmp " ); + do_addressing( buf ); +} + +static void bsr( char *buf ) { + sprintf( buf, "bsr " ); + do_relative( buf ); + flags = DASMFLAG_STEP_OVER; +} + +static void lbsr( char *buf ) { + sprintf( buf, "lbsr " ); + do_relative_word( buf ); + flags = DASMFLAG_STEP_OVER; +} + +static void decbjnz( char *buf ) { + sprintf( buf, "decb,jnz " ); + do_relative( buf ); + flags = DASMFLAG_STEP_OVER; +} + +static void decxjnz( char *buf ) { + sprintf( buf, "decx,jnz " ); + do_relative( buf ); + flags = DASMFLAG_STEP_OVER; +} + +static void addd( char *buf ) { + int val = get_next_byte() << 8; + + val |= get_next_byte(); + + sprintf( buf, "addd #$%04x", val ); +} + +static void subd( char *buf ) { + int val = get_next_byte() << 8; + + val |= get_next_byte(); + + sprintf( buf, "subd #$%04x", val ); +} + +static void tsta( char *buf ) { + sprintf( buf, "tsta" ); +} + +static void tstb( char *buf ) { + sprintf( buf, "tstb" ); +} + +static void tst2( char *buf ) { + sprintf( buf, "tst " ); + do_addressing( buf ); +} + +static void lsra( char *buf ) { + sprintf( buf, "lsra" ); +} + +static void lsrb( char *buf ) { + sprintf( buf, "lsrb" ); +} + +static void lsr2( char *buf ) { + sprintf( buf, "lsr " ); + do_addressing( buf ); +} + +static void asra( char *buf ) { + sprintf( buf, "asra" ); +} + +static void asrb( char *buf ) { + sprintf( buf, "asrb" ); +} + +static void asr2( char *buf ) { + sprintf( buf, "asr " ); + do_addressing( buf ); +} + +static void abx( char *buf ) { + sprintf( buf, "abx" ); +} + +static void sex( char *buf ) { + sprintf( buf, "sex" ); +} + +static void daa( char *buf ) { + sprintf( buf, "daa" ); +} + +static void mul( char *buf ) { + sprintf( buf, "mul" ); +} + +static void lmul( char *buf ) { + sprintf( buf, "lmul" ); +} + +static void divx( char *buf ) { + sprintf( buf, "div x,b" ); +} + +static void andcc( char *buf ) { + sprintf( buf, "andcc #$%02x", get_next_byte() ); +} + +static void orcc( char *buf ) { + sprintf( buf, "orcc #$%02x", get_next_byte() ); +} + +static void pushs( char *buf ) { + int mask = get_next_byte(), i; + + sprintf( buf, "pushs " ); + + for ( i = 0; i < 8; i++ ) { + if ( ( mask >> i ) & 1 ) { + strcat( buf, stack_reg_s[i] ); + mask &= ~( 1 << i ); + if ( mask ) + strcat( buf, "," ); + else + return; + } + } +} + +static void pushu( char *buf ) { + int mask = get_next_byte(), i; + + sprintf( buf, "pushu " ); + + for ( i = 0; i < 8; i++ ) { + if ( ( mask >> i ) & 1 ) { + strcat( buf, stack_reg_u[i] ); + mask &= ~( 1 << i ); + if ( mask ) + strcat( buf, "," ); + else + return; + } + } +} + +static void pulls( char *buf ) { + int mask = get_next_byte(), i; + + sprintf( buf, "pulls " ); + + for ( i = 0; i < 8; i++ ) { + if ( ( mask >> i ) & 1 ) { + strcat( buf, stack_reg_s[i] ); + if (i == 7) + flags = DASMFLAG_STEP_OUT; + mask &= ~( 1 << i ); + if ( mask ) + strcat( buf, "," ); + else + return; + } + } +} + +static void pullu( char *buf ) { + int mask = get_next_byte(), i; + + sprintf( buf, "pullu " ); + + for ( i = 0; i < 8; i++ ) { + if ( ( mask >> i ) & 1 ) { + strcat( buf, stack_reg_s[i] ); + mask &= ~( 1 << i ); + if ( mask ) + strcat( buf, "," ); + else + return; + } + } +} + +static void rola( char *buf ) { + sprintf( buf, "rola" ); +} + +static void rolb( char *buf ) { + sprintf( buf, "rolb" ); +} + +static void rol2( char *buf ) { + sprintf( buf, "rol " ); + do_addressing( buf ); +} + +static void bmove( char *buf ) { + sprintf( buf, "bmove y,x,u" ); +} + +static void move( char *buf ) { + sprintf( buf, "move y,x,u" ); +} + +static void bset( char *buf ) { + sprintf( buf, "bset a,x,u" ); +} + +static void bset2( char *buf ) { + sprintf( buf, "bset d,x,u" ); +} + +static void nop( char *buf ) { + sprintf( buf, "nop" ); +} + +static void tfr( char *buf ) { + int mask = get_next_byte(); + + sprintf( buf, "tfr " ); + + strcat( buf, tfrexg_reg[ mask & 0x07 ] ); + strcat( buf, "," ); + strcat( buf, tfrexg_reg[ ( mask >> 4 ) & 0x07 ] ); +} + +static void exg( char *buf ) { + int mask = get_next_byte(); + + sprintf( buf, "exg " ); + + strcat( buf, tfrexg_reg[ mask & 0x07 ] ); + strcat( buf, "," ); + strcat( buf, tfrexg_reg[ ( mask >> 4 ) & 0x07 ] ); +} + +static void lsrd( char *buf ) { + sprintf( buf, "lsrd #$%02x", get_next_byte() ); +} + +static void lsrd2( char *buf ) { + sprintf( buf, "lsrd " ); + do_addressing( buf ); +} + +static void rord( char *buf ) { + sprintf( buf, "rord #$%02x", get_next_byte() ); +} + +static void rord2( char *buf ) { + sprintf( buf, "rord " ); + do_addressing( buf ); +} + +static void asrd( char *buf ) { + sprintf( buf, "asrd #$%02x", get_next_byte() ); +} + +static void asrd2( char *buf ) { + sprintf( buf, "asrd " ); + do_addressing( buf ); +} + +static void asld( char *buf ) { + sprintf( buf, "asld #$%02x", get_next_byte() ); +} + +static void asld2( char *buf ) { + sprintf( buf, "asld " ); + do_addressing( buf ); +} + +static void rold( char *buf ) { + sprintf( buf, "rold #$%02x", get_next_byte() ); +} + +static void rold2( char *buf ) { + sprintf( buf, "rold " ); + do_addressing( buf ); +} + +static void lsrw( char *buf ) { + sprintf( buf, "lsrw " ); + do_addressing( buf ); +} + +static void rorw( char *buf ) { + sprintf( buf, "lsrw " ); + do_addressing( buf ); +} + +static void asrw( char *buf ) { + sprintf( buf, "asrw " ); + do_addressing( buf ); +} + +static void aslw( char *buf ) { + sprintf( buf, "aslw " ); + do_addressing( buf ); +} + +static void rolw( char *buf ) { + sprintf( buf, "rolw " ); + do_addressing( buf ); +} + +static void absa( char *buf ) { + sprintf( buf, "absa" ); +} + +static void absb( char *buf ) { + sprintf( buf, "absb" ); +} + +static void absd( char *buf ) { + sprintf( buf, "absd" ); +} + +/********************************************************************************* + + Opcode Table + +*********************************************************************************/ + +struct konami_opcode_def { + void (*decode)( char *buf ); + int confirmed; +}; + +static const konami_opcode_def op_table[256] = { + /* 00 */ { illegal, 0 }, + /* 01 */ { illegal, 0 }, + /* 02 */ { illegal, 0 }, + /* 03 */ { illegal, 0 }, + /* 04 */ { illegal, 0 }, + /* 05 */ { illegal, 0 }, + /* 06 */ { illegal, 0 }, + /* 07 */ { illegal, 0 }, + /* 08 */ { leax, 1 }, + /* 09 */ { leay, 1 }, + /* 0a */ { leau, 1 }, + /* 0b */ { leas, 0 }, + /* 0c */ { pushs, 1 }, + /* 0d */ { pushu, 0 }, + /* 0e */ { pulls, 1 }, + /* 0f */ { pullu, 0 }, + + /* 10 */ { lda, 1 }, + /* 11 */ { ldb, 1 }, + /* 12 */ { lda2, 1 }, + /* 13 */ { ldb2, 1 }, + /* 14 */ { adda, 1 }, + /* 15 */ { addb, 1 }, + /* 16 */ { adda2, 1 }, + /* 17 */ { addb2, 1 }, + /* 18 */ { adca, 1 }, + /* 19 */ { adcb, 1 }, + /* 1a */ { adca2, 1 }, + /* 1b */ { adcb2, 1 }, + /* 1c */ { suba, 1 }, + /* 1d */ { subb, 1 }, + /* 1e */ { suba2, 1 }, + /* 1f */ { subb2, 1 }, + + /* 20 */ { sbca, 0 }, + /* 21 */ { sbcb, 0 }, + /* 22 */ { sbca2, 0 }, + /* 23 */ { sbcb2, 0 }, + /* 24 */ { anda, 1 }, + /* 25 */ { andb, 1 }, + /* 26 */ { anda2, 1 }, + /* 27 */ { andb2, 1 }, + /* 28 */ { bita, 0 }, + /* 29 */ { bitb, 0 }, + /* 2a */ { bita2, 0 }, + /* 2b */ { bitb2, 0 }, + /* 2c */ { eora, 0 }, + /* 2d */ { eorb, 0 }, + /* 2e */ { eora2, 0 }, + /* 2f */ { eorb2, 0 }, + + /* 30 */ { ora, 1 }, + /* 31 */ { orb, 1 }, + /* 32 */ { ora2, 1 }, + /* 33 */ { orb2, 1 }, + /* 34 */ { cmpa, 1 }, + /* 35 */ { cmpb, 1 }, + /* 36 */ { cmpa2, 1 }, + /* 37 */ { cmpb2, 1 }, + /* 38 */ { setlines, 0 }, + /* 39 */ { setlines2, 0 }, + /* 3a */ { sta2, 1 }, + /* 3b */ { stb2, 1 }, + /* 3c */ { andcc, 1 }, + /* 3d */ { orcc, 0 }, + /* 3e */ { exg, 0 }, + /* 3f */ { tfr, 0 }, + + /* 40 */ { ldd, 1 }, + /* 41 */ { ldd2, 1 }, + /* 42 */ { ldx, 1 }, + /* 43 */ { ldx2, 1 }, + /* 44 */ { ldy, 1 }, + /* 45 */ { ldy2, 1 }, + /* 46 */ { ldu, 1 }, + /* 47 */ { ldu2, 1 }, + /* 48 */ { lds, 1 }, + /* 49 */ { lds2, 1 }, + /* 4a */ { cmpd, 1 }, + /* 4b */ { cmpd2, 1 }, + /* 4c */ { cmpx, 1 }, + /* 4d */ { cmpx2, 1 }, + /* 4e */ { cmpy, 1 }, + /* 4f */ { cmpy2, 1 }, + + /* 50 */ { cmpu, 1 }, + /* 51 */ { cmpu2, 1 }, + /* 52 */ { cmps, 1 }, + /* 53 */ { cmps2, 1 }, + /* 54 */ { addd, 0 }, + /* 55 */ { addd2, 0 }, + /* 56 */ { subd, 1 }, + /* 57 */ { subd2, 0 }, + /* 58 */ { std2, 1 }, + /* 59 */ { stx2, 1 }, + /* 5a */ { sty2, 1 }, + /* 5b */ { stu2, 1 }, + /* 5c */ { sts2, 1 }, + /* 5d */ { illegal, 0 }, + /* 5e */ { illegal, 0 }, + /* 5f */ { illegal, 0 }, + + /* 60 */ { bra, 1 }, + /* 61 */ { bhi, 1 }, + /* 62 */ { bcc, 1 }, + /* 63 */ { bne, 1 }, + /* 64 */ { bvc, 1 }, + /* 65 */ { bpl, 1 }, + /* 66 */ { bge, 1 }, + /* 67 */ { bgt, 1 }, + /* 68 */ { lbra, 1 }, + /* 69 */ { lbhi, 1 }, + /* 6a */ { lbcc, 1 }, + /* 6b */ { lbne, 1 }, + /* 6c */ { lbvc, 1 }, + /* 6d */ { lbpl, 1 }, + /* 6e */ { lbge, 1 }, + /* 6f */ { lbgt, 1 }, + + /* 70 */ { brn, 1 }, + /* 71 */ { bls, 1 }, + /* 72 */ { bcs, 1 }, + /* 73 */ { beq, 1 }, + /* 74 */ { bvs, 1 }, + /* 75 */ { bmi, 1 }, + /* 76 */ { blt, 1 }, + /* 77 */ { ble, 1 }, + /* 78 */ { lbrn, 1 }, + /* 79 */ { lbls, 1 }, + /* 7a */ { lbcs, 1 }, + /* 7b */ { lbeq, 1 }, + /* 7c */ { lbvs, 1 }, + /* 7d */ { lbmi, 1 }, + /* 7e */ { lblt, 1 }, + /* 7f */ { lble, 1 }, + + /* 80 */ { clra, 1 }, + /* 81 */ { clrb, 1 }, + /* 82 */ { clr2, 1 }, + /* 83 */ { coma, 1 }, + /* 84 */ { comb, 0 }, + /* 85 */ { com2, 0 }, + /* 86 */ { nega, 0 }, + /* 87 */ { negb, 0 }, + /* 88 */ { neg2, 0 }, + /* 89 */ { inca, 1 }, + /* 8a */ { incb, 1 }, + /* 8b */ { inc2, 1 }, + /* 8c */ { deca, 1 }, + /* 8d */ { decb, 1 }, + /* 8e */ { dec2, 1 }, + /* 8f */ { rts, 1 }, + + /* 90 */ { tsta, 0 }, + /* 91 */ { tstb, 0 }, + /* 92 */ { tst2, 0 }, + /* 93 */ { lsra, 1 }, + /* 94 */ { lsrb, 1 }, + /* 95 */ { lsr2, 0 }, + /* 96 */ { rora, 0 }, + /* 97 */ { rorb, 0 }, + /* 98 */ { ror2, 0 }, + /* 99 */ { asra, 0 }, + /* 9a */ { asrb, 0 }, + /* 9b */ { asr2, 0 }, + /* 9c */ { asla, 1 }, + /* 9d */ { aslb, 1 }, + /* 9e */ { asl2, 0 }, + /* 9f */ { rti, 1 }, + + /* a0 */ { rola, 1 }, + /* a1 */ { rolb, 0 }, + /* a2 */ { rol2, 0 }, + /* a3 */ { lsrw, 0 }, + /* a4 */ { rorw, 0 }, + /* a5 */ { asrw, 0 }, + /* a6 */ { aslw, 0 }, + /* a7 */ { rolw, 0 }, + /* a8 */ { jmp2, 1 }, + /* a9 */ { jsr2, 1 }, + /* aa */ { bsr, 1 }, + /* ab */ { lbsr, 1 }, + /* ac */ { decbjnz, 0 }, + /* ad */ { decxjnz, 0 }, + /* ae */ { nop, 0 }, + /* af */ { illegal, 0 }, + + /* b0 */ { abx, 0 }, + /* b1 */ { daa, 0 }, + /* b2 */ { sex, 0 }, + /* b3 */ { mul, 1 }, + /* b4 */ { lmul, 0 }, + /* b5 */ { divx, 0 }, + /* b6 */ { bmove, 1 }, + /* b7 */ { move, 0 }, + /* b8 */ { lsrd, 0 }, + /* b9 */ { lsrd2, 0 }, + /* ba */ { rord, 0 }, + /* bb */ { rord2, 0 }, + /* bc */ { asrd, 0 }, + /* bd */ { asrd2, 0 }, + /* be */ { asld, 0 }, + /* bf */ { asld2, 0 }, + + /* c0 */ { rold, 0 }, + /* c1 */ { rold2, 0 }, + /* c2 */ { clrd, 1 }, + /* c3 */ { clrw, 0 }, + /* c4 */ { negd, 0 }, + /* c5 */ { negw, 0 }, + /* c6 */ { incd, 0 }, + /* c7 */ { incw, 0 }, + /* c8 */ { decd, 0 }, + /* c9 */ { decw, 0 }, + /* ca */ { tstd, 0 }, + /* cb */ { tstw, 0 }, + /* cc */ { absa, 0 }, + /* cd */ { absb, 0 }, + /* ce */ { absd, 0 }, + /* cf */ { bset, 0 }, + + /* d0 */ { bset2, 0 }, + /* d1 */ { illegal, 0 }, + /* d2 */ { illegal, 0 }, + /* d3 */ { illegal, 0 }, + /* d4 */ { illegal, 0 }, + /* d5 */ { illegal, 0 }, + /* d6 */ { illegal, 0 }, + /* d7 */ { illegal, 0 }, + /* d8 */ { illegal, 0 }, + /* d9 */ { illegal, 0 }, + /* da */ { illegal, 0 }, + /* db */ { illegal, 0 }, + /* dc */ { illegal, 0 }, + /* dd */ { illegal, 0 }, + /* de */ { illegal, 0 }, + /* df */ { illegal, 0 }, + + /* e0 */ { illegal, 0 }, + /* e1 */ { illegal, 0 }, + /* e2 */ { illegal, 0 }, + /* e3 */ { illegal, 0 }, + /* e4 */ { illegal, 0 }, + /* e5 */ { illegal, 0 }, + /* e6 */ { illegal, 0 }, + /* e7 */ { illegal, 0 }, + /* e8 */ { illegal, 0 }, + /* e9 */ { illegal, 0 }, + /* ea */ { illegal, 0 }, + /* eb */ { illegal, 0 }, + /* ec */ { illegal, 0 }, + /* ed */ { illegal, 0 }, + /* ee */ { illegal, 0 }, + /* ef */ { illegal, 0 }, + + /* f0 */ { illegal, 0 }, + /* f1 */ { illegal, 0 }, + /* f2 */ { illegal, 0 }, + /* f3 */ { illegal, 0 }, + /* f4 */ { illegal, 0 }, + /* f5 */ { illegal, 0 }, + /* f6 */ { illegal, 0 }, + /* f7 */ { illegal, 0 }, + /* f8 */ { illegal, 0 }, + /* f9 */ { illegal, 0 }, + /* fa */ { illegal, 0 }, + /* fb */ { illegal, 0 }, + /* fc */ { illegal, 0 }, + /* fd */ { illegal, 0 }, + /* fe */ { illegal, 0 }, + /* ff */ { illegal, 0 } +}; + +CPU_DISASSEMBLE( konami ) +{ + buffer[0] = '\0'; + + local_pc = pc; + byte_count = 1; + opram_ptr = opram; + flags = 0; + + (op_table[*oprom].decode)( buffer ); + + return byte_count | flags | DASMFLAG_SUPPORTED; +} |