git.sur5r.net Git - cc65/blob - src/cc65/opcodes.c

   1 /*****************************************************************************/
   2 /*                                                                           */
   3 /*                                 opcodes.c                                 */
   4 /*                                                                           */
   5 /*                  Opcode and addressing mode definitions                   */
   6 /*                                                                           */
   7 /*                                                                           */
   8 /*                                                                           */
   9 /* (C) 2001      Ullrich von Bassewitz                                       */
  10 /*               Wacholderweg 14                                             */
  11 /*               D-70597 Stuttgart                                           */
  12 /* EMail:        uz@cc65.org                                                 */
  13 /*                                                                           */
  14 /*                                                                           */
  15 /* This software is provided 'as-is', without any expressed or implied       */
  16 /* warranty.  In no event will the authors be held liable for any damages    */
  17 /* arising from the use of this software.                                    */
  18 /*                                                                           */
  19 /* Permission is granted to anyone to use this software for any purpose,     */
  20 /* including commercial applications, and to alter it and redistribute it    */
  21 /* freely, subject to the following restrictions:                            */
  22 /*                                                                           */
  23 /* 1. The origin of this software must not be misrepresented; you must not   */
  24 /*    claim that you wrote the original software. If you use this software   */
  25 /*    in a product, an acknowledgment in the product documentation would be  */
  26 /*    appreciated but is not required.                                       */
  27 /* 2. Altered source versions must be plainly marked as such, and must not   */
  28 /*    be misrepresented as being the original software.                      */
  29 /* 3. This notice may not be removed or altered from any source              */
  30 /*    distribution.                                                          */
  31 /*                                                                           */
  32 /*****************************************************************************/
  33
  34
  35
  36 #include "stdlib.h"
  37 #include <string.h>
  38 #include <ctype.h>
  39
  40 /* common */
  41 #include "check.h"
  42
  43 /* cc65 */
  44 #include "codeinfo.h"
  45 #include "error.h"
  46 #include "opcodes.h"
  47
  48
  49
  50 /*****************************************************************************/
  51 /*                                   Data                                    */
  52 /*****************************************************************************/
  53
  54
  55
  56 /* Mapper table, mnemonic --> opcode */
  57 static const OPCDesc OPCTable[OPC_COUNT] = {
  58     { "adc", OPC_ADC, 0, CI_USE_A | CI_CHG_A    },
  59     { "and", OPC_AND, 0, CI_USE_A | CI_CHG_A    },
  60     { "asl", OPC_ASL, 0, CI_USE_A | CI_CHG_A    },
  61     { "bcc", OPC_BCC, 2, CI_BRA                 },
  62     { "bcs", OPC_BCS, 2, CI_BRA                 },
  63     { "beq", OPC_BEQ, 2, CI_BRA                 },
  64     { "bit", OPC_BIT, 0, CI_USE_A               },
  65     { "bmi", OPC_BMI, 2, CI_BRA                 },
  66     { "bne", OPC_BNE, 2, CI_BRA                 },
  67     { "bpl", OPC_BPL, 2, CI_BRA                 },
  68     { "bra", OPC_BRA, 2, CI_BRA                 },
  69     { "brk", OPC_BRK, 1, CI_NONE                },
  70     { "bvc", OPC_BVC, 2, CI_BRA                 },
  71     { "bvs", OPC_BVS, 2, CI_BRA                 },
  72     { "clc", OPC_CLC, 1, CI_CHG_NONE            },
  73     { "cld", OPC_CLD, 1, CI_CHG_NONE            },
  74     { "cli", OPC_CLI, 1, CI_CHG_NONE            },
  75     { "clv", OPC_CLV, 1, CI_CHG_NONE            },
  76     { "cmp", OPC_CMP, 0, CI_USE_A               },
  77     { "cpx", OPC_CPX, 0, CI_USE_X               },
  78     { "cpy", OPC_CPY, 0, CI_USE_Y               },
  79     { "dea", OPC_DEA, 1, CI_USE_A | CI_CHG_A    },
  80     { "dec", OPC_DEC, 0, CI_NONE                },
  81     { "dex", OPC_DEX, 1, CI_USE_X | CI_CHG_X    },
  82     { "dey", OPC_DEY, 1, CI_USE_Y | CI_CHG_Y    },
  83     { "eor", OPC_EOR, 0, CI_USE_A | CI_CHG_A    },
  84     { "ina", OPC_INA, 1, CI_USE_A | CI_CHG_A    },
  85     { "inc", OPC_INC, 0, CI_NONE                },
  86     { "inx", OPC_INX, 1, CI_USE_X | CI_CHG_X    },
  87     { "iny", OPC_INY, 1, CI_USE_Y | CI_CHG_Y    },
  88     { "jcc", OPC_JCC, 5, CI_BRA                 },
  89     { "jcs", OPC_JCS, 5, CI_BRA                 },
  90     { "jeq", OPC_JEQ, 5, CI_BRA                 },
  91     { "jmi", OPC_JMI, 5, CI_BRA                 },
  92     { "jmp", OPC_JMP, 3, CI_BRA                 },
  93     { "jne", OPC_JNE, 5, CI_BRA                 },
  94     { "jpl", OPC_JPL, 5, CI_BRA                 },
  95     { "jsr", OPC_JSR, 3, CI_NONE                },
  96     { "jvc", OPC_JVC, 5, CI_BRA                 },
  97     { "jvs", OPC_JVS, 5, CI_BRA                 },
  98     { "lda", OPC_LDA, 0, CI_CHG_A               },
  99     { "ldx", OPC_LDX, 0, CI_CHG_X               },
 100     { "ldy", OPC_LDY, 0, CI_CHG_Y               },
 101     { "lsr", OPC_LSR, 0, CI_USE_A | CI_CHG_A    },
 102     { "nop", OPC_NOP, 1, CI_NONE                },
 103     { "ora", OPC_ORA, 0, CI_USE_A | CI_CHG_A    },
 104     { "pha", OPC_PHA, 1, CI_USE_A               },
 105     { "php", OPC_PHP, 1, CI_NONE                },
 106     { "phx", OPC_PHX, 1, CI_USE_X               },
 107     { "phy", OPC_PHY, 1, CI_USE_Y               },
 108     { "pla", OPC_PLA, 1, CI_CHG_A               },
 109     { "plp", OPC_PLP, 1, CI_NONE                },
 110     { "plx", OPC_PLX, 1, CI_CHG_X               },
 111     { "ply", OPC_PLY, 1, CI_CHG_Y               },
 112     { "rol", OPC_ROL, 0, CI_USE_A | CI_CHG_A    },
 113     { "ror", OPC_ROR, 0, CI_USE_A | CI_CHG_A    },
 114     { "rti", OPC_RTI, 1, CI_NONE                },
 115     { "rts", OPC_RTS, 1, CI_NONE                },
 116     { "sbc", OPC_SBC, 0, CI_USE_A | CI_CHG_A    },
 117     { "sec", OPC_SEC, 1, CI_NONE                },
 118     { "sed", OPC_SED, 1, CI_NONE                },
 119     { "sei", OPC_SEI, 1, CI_NONE                },
 120     { "sta", OPC_STA, 0, CI_USE_A               },
 121     { "stx", OPC_STX, 0, CI_USE_X               },
 122     { "sty", OPC_STY, 0, CI_USE_Y               },
 123     { "tax", OPC_TAX, 1, CI_USE_A | CI_CHG_X    },
 124     { "tay", OPC_TAY, 1, CI_USE_A | CI_CHG_Y    },
 125     { "trb", OPC_TRB, 0, CI_USE_A               },
 126     { "tsb", OPC_TSB, 0, CI_USE_A               },
 127     { "tsx", OPC_TSX, 1, CI_CHG_X               },
 128     { "txa", OPC_TXA, 1, CI_USE_X | CI_CHG_A    },
 129     { "txs", OPC_TXS, 1, CI_USE_X               },
 130     { "tya", OPC_TYA, 1, CI_USE_Y | CI_CHG_A    }
 131 };
 132
 133
 134
 135 /*****************************************************************************/
 136 /*                                   Code                                    */
 137 /*****************************************************************************/
 138
 139
 140
 141 static int Compare (const void* Key, const void* Desc)
 142 /* Compare function for bsearch */
 143 {
 144     return strcmp (Key, ((OPCDesc*)Desc)->Mnemo);
 145 }
 146
 147
 148
 149 const OPCDesc* FindOpcode (const char* M)
 150 /* Find the given opcode and return the opcode number. If the opcode was not
 151  * found, return OPC_INVALID.
 152  */
 153 {
 154     unsigned I;
 155     unsigned Len;
 156
 157     /* Check the length of the given string, then copy it into local
 158      * storage, converting it to upper case.
 159      */
 160     char Mnemo[sizeof (OPCTable[0].Mnemo)];
 161     Len = strlen (M);
 162     if (Len >= sizeof (OPCTable[0].Mnemo)) {
 163         /* Invalid length means invalid opcode */
 164         return 0;
 165     }
 166     for (I = 0; I < Len; ++I) {
 167         Mnemo[I] = tolower (M[I]);
 168     }
 169     Mnemo[I] = '\0';
 170
 171     /* Search for the mnemonic in the table and return the result */
 172     return bsearch (Mnemo, OPCTable, OPC_COUNT, sizeof (OPCTable[0]), Compare);
 173 }
 174
 175
 176
 177 unsigned GetInsnSize (opc_t OPC, am_t AM)
 178 /* Return the size of the given instruction */
 179 {
 180     /* Get the opcode desc and check the size given there */
 181     const OPCDesc* D = &OPCTable[OPC];
 182     if (D->Size != 0) {
 183         return D->Size;
 184     }
 185
 186     /* Check the addressing mode. */
 187     switch (AM) {
 188         case AM_IMP:      return 1;
 189         case AM_ACC:      return 1;
 190         case AM_IMM:      return 2;
 191         case AM_ZP:       return 2;
 192         case AM_ZPX:      return 2;
 193         case AM_ABS:      return 3;
 194         case AM_ABSX:     return 3;
 195         case AM_ABSY:     return 3;
 196         case AM_ZPX_IND:  return 2;
 197         case AM_ZP_INDY:  return 2;
 198         case AM_ZP_IND:   return 2;
 199         default:          FAIL ("Invalid addressing mode");
 200     }
 201 }
 202
 203
 204
 205 const OPCDesc* GetOPCDesc (opc_t OPC)
 206 /* Get an opcode description */
 207 {
 208     /* Check the range */
 209     PRECONDITION (OPC >= (opc_t)0 && OPC < OPC_COUNT);
 210
 211     /* Return the description */
 212     return &OPCTable [OPC];
 213 }
 214
 215
 216
 217 unsigned GetAMUseInfo (am_t AM)
 218 /* Get usage info for the given addressing mode (addressing modes that use
 219  * index registers return CI_USE... info for these registers).
 220  */
 221 {
 222     /* Check the addressing mode. */
 223     switch (AM) {
 224         case AM_ACC:      return CI_USE_A;
 225         case AM_ZPX:      return CI_USE_X;
 226         case AM_ABSX:     return CI_USE_X;
 227         case AM_ABSY:     return CI_USE_Y;
 228         case AM_ZPX_IND:  return CI_USE_X;
 229         case AM_ZP_INDY:  return CI_USE_Y;
 230         default:          return CI_USE_NONE;
 231     }
 232 }
 233
 234
 235
 236 opc_t GetInverseBranch (opc_t OPC)
 237 /* Return a brahcn that reverse the condition of the branch given in OPC */
 238 {
 239     switch (OPC) {
 240         case OPC_BCC:   return OPC_BCS;
 241         case OPC_BCS:   return OPC_BCC;
 242         case OPC_BEQ:   return OPC_BNE;
 243         case OPC_BMI:   return OPC_BPL;
 244         case OPC_BNE:   return OPC_BEQ;
 245         case OPC_BPL:   return OPC_BMI;
 246         case OPC_BVC:   return OPC_BVS;
 247         case OPC_BVS:   return OPC_BVC;
 248         case OPC_JCC:   return OPC_JCS;
 249         case OPC_JCS:   return OPC_JCC;
 250         case OPC_JEQ:   return OPC_JNE;
 251         case OPC_JMI:   return OPC_JPL;
 252         case OPC_JNE:   return OPC_JEQ;
 253         case OPC_JPL:   return OPC_JMI;
 254         case OPC_JVC:   return OPC_JVS;
 255         case OPC_JVS:   return OPC_JVC;
 256         default:        Internal ("GetInverseBranch: Invalid opcode: %d", OPC);
 257     }
 258 }
 259
 260
 261