Shamusworld >> Repos - apple2/blob - src/dis65c02.cpp

   1 //
   2 // 65C02 disassembler
   3 //
   4 // by James Hammons
   5 // (c) 2005 Underground Software
   6 //
   7
   8 #include "dis65c02.h"
   9
  10 #include <stdio.h>
  11 #include <string.h>
  12 #include "log.h"
  13 #include "v65c02.h"
  14
  15
  16 // External shit
  17
  18 extern V65C02REGS mainCPU;//Hm. Shouldn't we pass this shit in? ANSWER: YES. !!! FIX !!!
  19
  20 // Private globals variables
  21
  22 static uint8_t op_mat[256] = {
  23         14, 6,  0,  0,  2,  2,  2,  2,  14, 1,  14, 0,  8,  8,  8,  13,
  24         13, 7,  5,  0,  2,  3,  3,  2,  14, 10, 14, 0,  8,  9,  9,  13,
  25         8,  6,  0,  0,  2,  2,  2,  2,  14, 1,  14, 0,  8,  8,  8,  13,
  26         13, 7,  5,  0,  3,  3,  3,  2,  14, 10, 14, 0,  9,  9,  9,  13,
  27         14, 6,  0,  0,  0,  2,  2,  2,  14, 1,  14, 0,  8,  8,  8,  13,
  28         13, 7,  5,  0,  0,  3,  3,  2,  14, 10, 14, 0,  0,  9,  9,  13,
  29         14, 6,  0,  0,  2,  2,  2,  2,  14, 1,  14, 0,  11, 8,  8,  13,
  30         13, 7,  5,  0,  3,  3,  3,  2,  14, 10, 14, 0,  12, 9,  9,  13,
  31         13, 6,  0,  0,  2,  2,  2,  2,  14, 1,  14, 0,  8,  8,  8,  13,
  32         13, 7,  5,  0,  3,  3,  4,  2,  14, 10, 14, 0,  8,  9,  9,  13,
  33         1,  6,  1,  0,  2,  2,  2,  2,  14, 1,  14, 0,  8,  8,  8,  13,
  34         13, 7,  5,  0,  3,  3,  4,  2,  14, 10, 14, 0,  9,  9,  10, 13,
  35         1,  6,  0,  0,  2,  2,  2,  2,  14, 1,  14, 0,  8,  8,  8,  13,
  36         13, 7,  5,  0,  0,  3,  3,  2,  14, 10, 14, 0,  0,  9,  9,  13,
  37         1,  6,  0,  0,  2,  2,  2,  2,  14, 1,  14, 0,  8,  8,  8,  13,
  38         13, 7,  5,  0,  0,  3,  3,  2,  14, 10, 14, 0,  0,  9,  9,  13
  39 };
  40
  41 static uint8_t mnemonics[256][5] = {
  42         "BRK ","ORA ","??? ","??? ","TSB ","ORA ","ASL ","RMB0",
  43         "PHP ","ORA ","ASL ","??? ","TSB ","ORA ","ASL ","BBR0",
  44         "BPL ","ORA ","ORA ","??? ","TRB ","ORA ","ASL ","RMB1",
  45         "CLC ","ORA ","INC ","??? ","TRB ","ORA ","ASL ","BBR1",
  46         "JSR ","AND ","??? ","??? ","BIT ","AND ","ROL ","RMB2",
  47         "PLP ","AND ","ROL ","??? ","BIT ","AND ","ROL ","BBR2",
  48         "BMI ","AND ","AND ","??? ","BIT ","AND ","ROL ","RMB3",
  49         "SEC ","AND ","DEC ","??? ","BIT ","AND ","ROL ","BBR3",
  50         "RTI ","EOR ","??? ","??? ","??? ","EOR ","LSR ","RMB4",
  51         "PHA ","EOR ","LSR ","??? ","JMP ","EOR ","LSR ","BBR4",
  52         "BVC ","EOR ","EOR ","??? ","??? ","EOR ","LSR ","RMB5",
  53         "CLI ","EOR ","PHY ","??? ","??? ","EOR ","LSR ","BBR5",
  54         "RTS ","ADC ","??? ","??? ","STZ ","ADC ","ROR ","RMB6",
  55         "PLA ","ADC ","ROR ","??? ","JMP ","ADC ","ROR ","BBR6",
  56         "BVS ","ADC ","ADC ","??? ","STZ ","ADC ","ROR ","RMB7",
  57         "SEI ","ADC ","PLY ","??? ","JMP ","ADC ","ROR ","BBR7",
  58         "BRA ","STA ","??? ","??? ","STY ","STA ","STX ","SMB0",
  59         "DEY ","BIT ","TXA ","??? ","STY ","STA ","STX ","BBS0",
  60         "BCC ","STA ","STA ","??? ","STY ","STA ","STX ","SMB1",
  61         "TYA ","STA ","TXS ","??? ","STZ ","STA ","STZ ","BBS1",
  62         "LDY ","LDA ","LDX ","??? ","LDY ","LDA ","LDX ","SMB2",
  63         "TAY ","LDA ","TAX ","??? ","LDY ","LDA ","LDX ","BBS2",
  64         "BCS ","LDA ","LDA ","??? ","LDY ","LDA ","LDX ","SMB3",
  65         "CLV ","LDA ","TSX ","??? ","LDY ","LDA ","LDX ","BBS3",
  66         "CPY ","CMP ","??? ","??? ","CPY ","CMP ","DEC ","SMB4",
  67         "INY ","CMP ","DEX ","??? ","CPY ","CMP ","DEC ","BBS4",
  68         "BNE ","CMP ","CMP ","??? ","??? ","CMP ","DEC ","SMB5",
  69         "CLD ","CMP ","PHX ","??? ","??? ","CMP ","DEC ","BBS5",
  70         "CPX ","SBC ","??? ","??? ","CPX ","SBC ","INC ","SMB6",
  71         "INX ","SBC ","NOP ","??? ","CPX ","SBC ","INC ","BBS6",
  72         "BEQ ","SBC ","SBC ","??? ","??? ","SBC ","INC ","SMB7",
  73         "SED ","SBC ","PLX ","??? ","??? ","SBC ","INC ","BBS7"
  74 };
  75
  76
  77 //
  78 // Display bytes in mem in hex
  79 //
  80 static void DisplayBytes(char * outbuf, uint16_t src, uint32_t dst)
  81 {
  82         char buf[32];
  83         sprintf(outbuf, "%04X: ", src);
  84         uint8_t cnt = 0;
  85
  86         // That should fix the $FFFF bug...
  87         if (src > dst)
  88                 dst += 0x10000;
  89
  90         for(uint32_t i=src; i<dst; i++)
  91         {
  92                 sprintf(buf, "%02X ", mainCPU.RdMem(i));
  93                 strcat(outbuf, buf);
  94                 cnt++;
  95         }
  96
  97         // Pad the leftover spaces...
  98         for(int i=cnt; i<3; i++)
  99         {
 100                 sprintf(buf, "   ");
 101                 strcat(outbuf, buf);
 102         }
 103 }
 104
 105
 106 //
 107 // Decode a 65C02 instruction
 108 //
 109 int Decode65C02(char * outbuf, uint16_t pc)
 110 {
 111         char buf[32], buf2[32];
 112
 113         uint16_t addr = pc;
 114         uint16_t w;
 115         uint8_t opcode = mainCPU.RdMem(addr++); // Get the opcode
 116
 117         switch (op_mat[opcode])                                 // Decode the addressing mode...
 118         {
 119         case 0:                                                                 // Illegal
 120                 sprintf(buf, "???");
 121                 break;
 122         case 1:                                                                 // Immediate
 123                 sprintf(buf, "%s #$%02X", mnemonics[opcode], mainCPU.RdMem(addr++));
 124                 break;
 125         case 2:                                                                 // Zero page
 126                 sprintf(buf, "%s $%02X", mnemonics[opcode], mainCPU.RdMem(addr++));
 127                 break;
 128         case 3:                                                                 // Zero page, X
 129                 sprintf(buf, "%s $%02X,X", mnemonics[opcode], mainCPU.RdMem(addr++));
 130                 break;
 131         case 4:                                                                 // Zero page, Y
 132                 sprintf(buf, "%s $%02X,Y", mnemonics[opcode], mainCPU.RdMem(addr++));
 133                 break;
 134         case 5:                                                                 // Zero page indirect
 135                 sprintf(buf, "%s ($%02X)", mnemonics[opcode], mainCPU.RdMem(addr++));
 136                 break;
 137         case 6:                                                                 // Zero page, X indirect
 138                 sprintf(buf, "%s ($%02X,X)", mnemonics[opcode], mainCPU.RdMem(addr++));
 139                 break;
 140         case 7:                                                                 // Zero page, Y indirect
 141                 sprintf(buf, "%s ($%02X),Y", mnemonics[opcode], mainCPU.RdMem(addr++));
 142                 break;
 143         case 8:                                                                 // Absolute
 144                 w = mainCPU.RdMem(addr++);
 145                 w |= mainCPU.RdMem(addr++) << 8;
 146                 sprintf(buf, "%s $%04X", mnemonics[opcode], w);
 147                 break;
 148         case 9:                                                                 // Absolute, X
 149                 w = mainCPU.RdMem(addr++);
 150                 w |= mainCPU.RdMem(addr++) << 8;
 151                 sprintf(buf, "%s $%04X,X", mnemonics[opcode], w);
 152                 break;
 153         case 10:                                                                // Absolute, Y
 154                 w = mainCPU.RdMem(addr++);
 155                 w |= mainCPU.RdMem(addr++) << 8;
 156                 sprintf(buf, "%s $%04X,Y", mnemonics[opcode], w);
 157                 break;
 158         case 11:                                                                // Indirect
 159                 w = mainCPU.RdMem(addr++);
 160                 w |= mainCPU.RdMem(addr++) << 8;
 161                 sprintf(buf, "%s ($%04X)", mnemonics[opcode], w);
 162                 break;
 163         case 12:                                                                // Indirect, X
 164                 w = mainCPU.RdMem(addr++);
 165                 w |= mainCPU.RdMem(addr++) << 8;
 166                 sprintf(buf, "%s ($%04X,X)", mnemonics[opcode], w);
 167                 break;
 168         case 13:                                                                // Relative
 169                 sprintf(buf, "%s $%04X", mnemonics[opcode], addr + (int16_t)((int8_t)mainCPU.RdMem(addr)) + 1);
 170                 addr++;
 171                 break;
 172         case 14:                                                                // Inherent
 173                 sprintf(buf, "%s ", mnemonics[opcode]);
 174                 break;
 175         }
 176
 177         DisplayBytes(buf2, pc, addr);                   // Show bytes
 178         sprintf(outbuf, "%s %-14s", buf2, buf); // Display opcode & addressing, etc.
 179
 180         return addr - pc;
 181 }
 182