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

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