Shamusworld >> Repos - virtualjaguar/blob - src/jagdasm.cpp

   1 //
   2 // Jaguar RISC Disassembly
   3 //
   4 // Originally by David Raingeard
   5 // GCC/SDL port by Niels Wagenaar (Linux/WIN32) and Carwin Jones (BeOS)
   6 // Minor cleanups by James Hammons
   7 // (C) 2012 Underground Software
   8 //
   9 // JLH = James Hammons <jlhamm@acm.org>
  10 //
  11 // Who  When        What
  12 // ---  ----------  -------------------------------------------------------------
  13 // JLH  06/01/2012  Created this log (long overdue! ;-)
  14 //
  15
  16 #include "jagdasm.h"
  17
  18 #include <stdio.h>
  19 #include "jaguar.h"
  20
  21 #define ROPCODE(a) JaguarReadWord(a)
  22
  23 uint8 convert_zero[32] =
  24 { 32,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31 };
  25
  26 const char * condition[32] =
  27 {
  28         "",
  29         "nz,",
  30         "z,",
  31         "???,",
  32         "nc,",
  33         "nc nz,",
  34         "nc z,",
  35         "???,",
  36
  37         "c,",
  38         "c nz,",
  39         "c z,",
  40         "???,",
  41         "???,",
  42         "???,",
  43         "???,",
  44         "???,",
  45
  46         "???,",
  47         "???,",
  48         "???,",
  49         "???,",
  50         "nn,",
  51         "nn nz,",
  52         "nn z,",
  53         "???,",
  54
  55         "n,",
  56         "n nz,",
  57         "n z,",
  58         "???,",
  59         "???,",
  60         "???,",
  61         "???,",
  62         "never,"
  63 };
  64
  65
  66
  67 char * signed_16bit(int16 val)
  68 {
  69         static char temp[10];
  70
  71         if (val < 0)
  72                 sprintf(temp, "-$%X", -val);
  73         else
  74                 sprintf(temp, "$%X", val);
  75
  76         return temp;
  77 }
  78
  79 unsigned dasmjag(int dsp_type, char * bufferOut, unsigned pc)
  80 {
  81         char buffer[64];
  82         int op = ROPCODE(pc);
  83         int reg1 = (op >> 5) & 31;
  84         int reg2 = op & 31;
  85         int size = 2;
  86
  87         pc += 2;
  88         switch (op >> 10)
  89         {
  90                 case 0:         sprintf(buffer, "ADD     R%02d,R%02d", reg1, reg2);                                     break;
  91                 case 1:         sprintf(buffer, "ADDC    R%02d,R%02d", reg1, reg2);                                     break;
  92                 case 2:         sprintf(buffer, "ADDQ    $%X,R%02d", convert_zero[reg1], reg2); break;
  93                 case 3:         sprintf(buffer, "ADDQT   $%X,R%02d", convert_zero[reg1], reg2); break;
  94                 case 4:         sprintf(buffer, "SUB     R%02d,R%02d", reg1, reg2);                                     break;
  95                 case 5:         sprintf(buffer, "SUBC    R%02d,R%02d", reg1, reg2);                                     break;
  96                 case 6:         sprintf(buffer, "SUBQ    $%X,R%02d", convert_zero[reg1], reg2); break;
  97                 case 7:         sprintf(buffer, "SUBQT   $%X,R%02d", convert_zero[reg1], reg2); break;
  98                 case 8:         sprintf(buffer, "NEG     R%02d", reg2);                                                 break;
  99                 case 9:         sprintf(buffer, "AND     R%02d,R%02d", reg1, reg2);                                     break;
 100                 case 10:        sprintf(buffer, "OR      R%02d,R%02d", reg1, reg2);                                     break;
 101                 case 11:        sprintf(buffer, "XOR     R%02d,R%02d", reg1, reg2);                                     break;
 102                 case 12:        sprintf(buffer, "NOT     R%02d", reg2);                                                 break;
 103                 case 13:        sprintf(buffer, "BTST    $%X,R%02d", reg1, reg2);                                       break;
 104                 case 14:        sprintf(buffer, "BSET    $%X,R%02d", reg1, reg2);                                       break;
 105                 case 15:        sprintf(buffer, "BCLR    $%X,R%02d", reg1, reg2);                                       break;
 106                 case 16:        sprintf(buffer, "MULT    R%02d,R%02d", reg1, reg2);                                     break;
 107                 case 17:        sprintf(buffer, "IMULT   R%02d,R%02d", reg1, reg2);                                     break;
 108                 case 18:        sprintf(buffer, "IMULTN  R%02d,R%02d", reg1, reg2);                                     break;
 109                 case 19:        sprintf(buffer, "RESMAC  R%02d", reg2);                                                 break;
 110                 case 20:        sprintf(buffer, "IMACN   R%02d,R%02d", reg1, reg2);                                     break;
 111                 case 21:        sprintf(buffer, "DIV     R%02d,R%02d", reg1, reg2);                                     break;
 112                 case 22:        sprintf(buffer, "ABS     R%02d", reg2);                                                 break;
 113                 case 23:        sprintf(buffer, "SH      R%02d,R%02d", reg1, reg2);                                     break;
 114                 case 24:        sprintf(buffer, "SHLQ    $%X,R%02d", 32 - convert_zero[reg1], reg2);    break;
 115                 case 25:        sprintf(buffer, "SHRQ    $%X,R%02d", convert_zero[reg1], reg2); break;
 116                 case 26:        sprintf(buffer, "SHA     R%02d,R%02d", reg1, reg2);                                     break;
 117                 case 27:        sprintf(buffer, "SHARQ   $%X,R%02d", convert_zero[reg1], reg2); break;
 118                 case 28:        sprintf(buffer, "ROR     R%02d,R%02d", reg1, reg2);                                     break;
 119                 case 29:        sprintf(buffer, "RORQ    $%X,R%02d", convert_zero[reg1], reg2); break;
 120                 case 30:        sprintf(buffer, "CMP     R%02d,R%02d", reg1, reg2);                                     break;
 121                 case 31:        sprintf(buffer, "CMPQ    %s,R%02d", signed_16bit((int16)(reg1 << 11) >> 11), reg2);break;
 122                 case 32:        if (dsp_type == JAGUAR_GPU)
 123                                                 sprintf(buffer, "SAT8    R%02d", reg2);
 124                                         else
 125                                                 sprintf(buffer, "SUBQMOD $%X,R%02d", convert_zero[reg1], reg2);
 126                                         break;
 127                 case 33:        if (dsp_type == JAGUAR_GPU)
 128                                                 sprintf(buffer, "SAT16   R%02d", reg2);
 129                                         else
 130                                                 sprintf(buffer, "SAT16S  R%02d", reg2);
 131                                         break;
 132                 case 34:        sprintf(buffer, "MOVE    R%02d,R%02d", reg1, reg2);                                     break;
 133                 case 35:        sprintf(buffer, "MOVEQ   %d,R%02d", reg1, reg2);                                        break;
 134                 case 36:        sprintf(buffer, "MOVETA  R%02d,R%02d", reg1, reg2);                                     break;
 135                 case 37:        sprintf(buffer, "MOVEFA  R%02d,R%02d", reg1, reg2);                                     break;
 136                 case 38:        sprintf(buffer, "MOVEI   $%08X,R%02d", ROPCODE(pc) | (ROPCODE(pc+2)<<16), reg2); size = 6; break;
 137                 case 39:        sprintf(buffer, "LOADB   (R%02d),R%02d", reg1, reg2);                                   break;
 138                 case 40:        sprintf(buffer, "LOADW   (R%02d),R%02d", reg1, reg2);                                   break;
 139                 case 41:        sprintf(buffer, "LOAD    (R%02d),R%02d", reg1, reg2);                                   break;
 140                 case 42:        if (dsp_type == JAGUAR_GPU)
 141                                                 sprintf(buffer, "LOADP   (R%02d),R%02d", reg1, reg2);
 142                                         else
 143                                                 sprintf(buffer, "SAT32S  R%02d", reg2);
 144                                         break;
 145                 case 43:        sprintf(buffer, "LOAD    (R14+$%X),R%02d", convert_zero[reg1]*4, reg2);break;
 146                 case 44:        sprintf(buffer, "LOAD    (R15+$%X),R%02d", convert_zero[reg1]*4, reg2);break;
 147                 case 45:        sprintf(buffer, "STOREB  R%02d,(R%02d)", reg2, reg1);                           break;
 148                 case 46:        sprintf(buffer, "STOREW  R%02d,(R%02d)", reg2, reg1);                           break;
 149                 case 47:        sprintf(buffer, "STORE   R%02d,(R%02d)", reg2, reg1);                                   break;
 150                 case 48:        if (dsp_type == JAGUAR_GPU)
 151                                                 sprintf(buffer, "STOREP  R%02d,(R%02d)", reg2, reg1);
 152                                         else
 153                                                 sprintf(buffer, "MIRROR  R%02d", reg2);
 154                                         break;
 155                 case 49:        sprintf(buffer, "STORE   R%02d,(R14+$%X)", reg2, convert_zero[reg1]*4);break;
 156                 case 50:        sprintf(buffer, "STORE   R%02d,(R15+$%X)", reg2, convert_zero[reg1]*4);break;
 157                 case 51:        sprintf(buffer, "MOVE    PC,R%02d", reg2);                                                      break;
 158                 case 52:        sprintf(buffer, "JUMP    %s(R%02d)", condition[reg2], reg1);                    break;
 159                 case 53:        sprintf(buffer, "JR      %s%08X", condition[reg2], pc + ((int8)(reg1 << 3) >> 2)); break;
 160                 case 54:        sprintf(buffer, "MMULT   R%02d,R%02d", reg1, reg2);                                     break;
 161                 case 55:        sprintf(buffer, "MTOI    R%02d,R%02d", reg1, reg2);                                     break;
 162                 case 56:        sprintf(buffer, "NORMI   R%02d,R%02d", reg1, reg2);                                     break;
 163                 case 57:        sprintf(buffer, "NOP");                                                                                 break;
 164                 case 58:        sprintf(buffer, "LOAD    (R14+R%02d),R%02d", reg1, reg2);                               break;
 165                 case 59:        sprintf(buffer, "LOAD    (R15+R%02d),R%02d", reg1, reg2);                               break;
 166                 case 60:        sprintf(buffer, "STORE   R%02d,(R14+R%02d)", reg2, reg1);                               break;
 167                 case 61:        sprintf(buffer, "STORE   R%02d,(R15+R%02d)", reg2, reg1);                               break;
 168                 case 62:        if (dsp_type == JAGUAR_GPU)
 169                                                 sprintf(buffer, "SAT24   R%02d", reg2);
 170                                         else
 171                                                 sprintf(buffer, "illegal");
 172                                         break;
 173                 case 63:        if (dsp_type == JAGUAR_GPU)
 174                                                 sprintf(buffer, (reg1 ? "UNPACK  R%02d" : "PACK    R%02d"), reg2);
 175                                         else
 176                                                 sprintf(buffer, "ADDQMOD $%X,R%02d", convert_zero[reg1], reg2);
 177                                         break;
 178         }
 179         sprintf(bufferOut,"%-24s (%04X)", buffer, op);
 180
 181         return size;
 182 }