Shamusworld >> Repos - stargem2/blob - src/dis6808.cpp

   1 //
   2 // 6808 disassembler
   3 //
   4 // by James Hammons
   5 // (C) 2004 Underground Software
   6 //
   7
   8 #include "dis6808.h"
   9
  10 #include <stdio.h>
  11 #include <string>
  12 #include "v6808.h"
  13 #include "log.h"
  14
  15 using namespace std;
  16
  17 // External shit
  18
  19 extern V6808REGS soundCPU;//Hm.
  20
  21 // Private globals variables
  22
  23 static char op_mat[256] = {
  24   0, 5, 0, 0, 0, 0, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
  25   5, 5, 0, 0, 0, 0, 5, 5, 0, 5, 0, 5, 0, 0, 0, 0,
  26   3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  27   5, 5, 5, 5, 5, 5, 5, 5, 0, 5, 0, 5, 0, 0, 5, 5,
  28   5, 0, 0, 5, 5, 0, 5, 5, 5, 5, 5, 0, 5, 5, 0, 5,
  29   5, 0, 0, 5, 5, 0, 5, 5, 5, 5, 5, 0, 5, 5, 0, 5,
  30   7, 0, 0, 7, 7, 0, 7, 7, 7, 7, 7, 0, 7, 7, 7, 7,
  31   2, 0, 0, 2, 2, 0, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2,
  32   8, 8, 8, 0, 8, 8, 8, 0, 8, 8, 8, 8, 9, 3, 9, 0,
  33   1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,
  34   7, 7, 7, 0, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
  35   2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  36   8, 8, 8, 0, 8, 8, 8, 0, 8, 8, 8, 8, 0, 0, 9, 0,
  37   1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1,
  38   7, 7, 7, 0, 7, 7, 7, 7, 7, 7, 7, 7, 0, 0, 7, 7,
  39   2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 2, 2
  40 };
  41
  42 static char mnemonics[256][6] = {
  43   "???  ","NOP  ","???  ","???  ","???  ","???  ","TAP  ","TPA  ",
  44   "INX  ","DEX  ","CLV  ","SEV  ","CLC  ","SEC  ","CLI  ","SEI  ",
  45   "SBA  ","CBA  ","???  ","???  ","???  ","???  ","TAB  ","TBA  ",
  46   "???  ","DAA  ","???  ","ABA  ","???  ","???  ","???  ","???  ",
  47   "BRA  ","???  ","BHI  ","BLS  ","BCC  ","BCS  ","BNE  ","BEQ  ",
  48   "BVC  ","BVS  ","BPL  ","BMI  ","BGE  ","BLT  ","BGT  ","BLE  ",
  49   "TSX  ","INS  ","PULA ","PULB ","DES  ","TXS  ","PSHA ","PSHB ",
  50   "???  ","RTS  ","???  ","RTI  ","???  ","???  ","WAI  ","SWI  ",
  51   "NEGA ","???  ","???  ","COMA ","LSRA ","???  ","RORA ","ASRA ",
  52   "ASLA ","ROLA ","DECA ","???  ","INCA ","TSTA ","???  ","CLRA ",
  53   "NEGB ","???  ","???  ","COMB ","LSRB ","???  ","RORB ","ASRB ",
  54   "ASLB ","ROLB ","DECB ","???  ","INCB ","TSTB ","???  ","CLRB ",
  55   "NEG  ","???  ","???  ","COM  ","LSR  ","???  ","ROR  ","ASR  ",
  56   "ASL  ","ROL  ","DEC  ","???  ","INC  ","TST  ","JMP  ","CLR  ",
  57   "NEG  ","???  ","???  ","COM  ","LSR  ","???  ","ROR  ","ASR  ",
  58   "ASL  ","ROL  ","DEC  ","???  ","INC  ","TST  ","JMP  ","CLR  ",
  59   "SUBA ","CMPA ","SBCA ","???  ","ANDA ","BITA ","LDAA ","???  ",
  60   "EORA ","ADCA ","ORAA ","ADDA ","CPX  ","BSR  ","LDS  ","???  ",
  61   "SUBA ","CMPA ","SBCA ","???  ","ANDA ","BITA ","LDAA ","STAA ",
  62   "EORA ","ADCA ","ORAA ","ADDA ","CPX  ","???  ","LDS  ","STS  ",
  63   "SUBA ","CMPA ","SBCA ","???  ","ANDA ","BITA ","LDAA ","STAA ",
  64   "EORA ","ADCA ","ORAA ","ADDA ","CPX  ","JSR  ","LDS  ","STS  ",
  65   "SUBA ","CMPA ","SBCA ","???  ","ANDA ","BITA ","LDAA ","STAA ",
  66   "EORA ","ADCA ","ORAA ","ADDA ","CPX  ","JSR  ","LDS  ","STS  ",
  67   "SUBB ","CMPB ","SBCB ","???  ","ANDB ","BITB ","LDAB ","???  ",
  68   "EORB ","ADCB ","ORAB ","ADDB ","???  ","???  ","LDX  ","???  ",
  69   "SUBB ","CMPB ","SBCB ","???  ","ANDB ","BITB ","LDAB ","STAB ",
  70   "EORB ","ADCB ","ORAB ","ADDB ","???  ","???  ","LDX  ","STX  ",
  71   "SUBB ","CMPB ","SBCB ","???  ","ANDB ","BITB ","LDAB ","STAB ",
  72   "EORB ","ADCB ","ORAB ","ADDB ","???  ","???  ","LDX  ","STX  ",
  73   "SUBB ","CMPB ","SBCB ","???  ","ANDB ","BITB ","LDAB ","STAB ",
  74   "EORB ","ADCB ","ORAB ","ADDB ","???  ","???  ","LDX  ","STX  "
  75 };
  76
  77 //
  78 // Display bytes in mem in hex
  79 //
  80 static void DisplayBytes(uint16_t src, uint32_t dst)
  81 {
  82         WriteLog("%04X: ", src);
  83         uint8_t cnt = 0;                                                                                // Init counter...
  84
  85         if (src > dst)
  86                 dst += 0x10000;                                                                 // That should fix the FFFF bug...
  87
  88         for(uint32_t i=src; i<dst; i++)
  89         {
  90                 WriteLog("%02X ", soundCPU.RdMem(i));
  91                 cnt++;                                                                                  // Bump counter...
  92         }
  93
  94         for(int i=cnt; i<5; i++)                                                        // Pad the leftover spaces...
  95                 WriteLog("   ");
  96 }
  97
  98 //
  99 // Decode a 6808 instruction
 100 //
 101 int Decode6808(uint16_t pc)
 102 {
 103         char outbuf[80];
 104
 105         uint16_t addr = pc, offset;
 106         uint8_t opcode = soundCPU.RdMem(addr++);                        // Get the opcode
 107
 108         switch (op_mat[opcode])                                                         // Decode the addressing mode...
 109         {
 110         case 0:                                                                                         // Illegal
 111                 sprintf(outbuf, "???          ");
 112                 break;
 113         case 1:                                                                                         // Zero page
 114                 sprintf(outbuf, "%s $%02X    ", mnemonics[opcode], soundCPU.RdMem(addr++));
 115                 break;
 116         case 2:                                                                                         // Absolute
 117 //              sprintf(outbuf, "%s $%04X", mnemonics[opcode], (soundCPU.RdMem(addr++) << 8) | soundCPU.RdMem(addr++));
 118                 offset = (soundCPU.RdMem(addr + 0) << 8) | soundCPU.RdMem(addr + 1);
 119                 addr += 2;
 120                 sprintf(outbuf, "%s $%04X  ", mnemonics[opcode], offset);
 121                 break;
 122         case 3:                                                                                         // Relative
 123 //              sprintf(outbuf, "%s $%04X", mnemonics[opcode], ++addr + (int16)(int8)soundCPU.RdMem(addr));
 124                 offset = addr + 1 + (int16_t)(int8_t)soundCPU.RdMem(addr);
 125                 addr++;
 126                 sprintf(outbuf, "%s $%04X  ", mnemonics[opcode], offset);
 127                 break;
 128         case 5:                                                                                         // Inherent
 129                 sprintf(outbuf, "%s        ", mnemonics[opcode]);
 130                 break;
 131         case 7:                                                                                         // Indexed
 132                 sprintf(outbuf, "%s $%02X,X  ", mnemonics[opcode], soundCPU.RdMem(addr++));
 133                 break;
 134         case 8:                                                                                         // Immediate
 135                 sprintf(outbuf, "%s #$%02X   ", mnemonics[opcode], soundCPU.RdMem(addr++));
 136                 break;
 137         case 9:                                                                                         // Long Immediate
 138 //              sprintf(outbuf, "%s #$%04X", mnemonics[opcode], (soundCPU.RdMem(addr++) << 8) | soundCPU.RdMem(addr++));
 139                 offset = (soundCPU.RdMem(addr + 0) << 8) | soundCPU.RdMem(addr + 1);
 140                 addr += 2;
 141                 sprintf(outbuf, "%s #$%04X ", mnemonics[opcode], offset);
 142                 break;
 143         }
 144
 145         DisplayBytes(pc, addr);                                                         // Show bytes
 146         WriteLog("%s", outbuf);                                                         // Display opcode & addressing, etc.
 147
 148         return addr - pc;
 149 }