Subversion Repositories or1k

#define fetch8(x) fetch8func((cycles++,(x)))

#define NFAKES 16

typedef struct

  {

    unsigned  a;

    unsigned  x;

    unsigned  y;

    unsigned  pc;               /* Keep pbr in there too */

    unsigned  dbr;

    unsigned  d;

    unsigned  s;

    unsigned  p;

    unsigned  e;

    unsigned  char *memory;

    unsigned  int exception;

    unsigned  int ticks;

    unsigned  int cycles;

    unsigned  int insts;

    unsigned  int r[NFAKES];

  }

saved_state_type;

#define GET_P      \

  ((GET_NBIT << 7) \

 | (GET_VBIT << 6) \

 | (GET_MBIT << 5) \

 | (GET_XBIT << 4) \

 | (GET_DBIT << 3) \

 | (GET_IBIT << 2) \

 | (GET_ZBIT << 1) \

 | (GET_CBIT << 0))

#define SET_P(_bits)   \

{ int bits = _bits;    \

SET_NBIT((bits>>7)&1); \

SET_VBIT((bits>>6)&1); \

SET_MBIT((bits>>5)&1); \

SET_XBIT((bits>>4)&1); \

SET_DBIT((bits>>3)&1); \

SET_IBIT((bits>>2)&1); \

SET_ZBIT((bits>>1)&1); \

SET_CBIT((bits>>0)&1);  }

#define BFLAG           (1<<4)

#define DFLAG           (1<<3)

#define GET_A           (the_a)

#define GET_E           (the_e)

#define GET_B           (the_b)

#define GET_CBIT        (the_cbit)

#define GET_D           (the_d)

#define GET_DBIT        (the_dbit)

#define GET_DBR_HIGH    (the_dbr)

#define GET_DBR_LOW     (the_dbr >> 16)

#define GET_DPR         (the_dpr)

#define GET_IBIT        (the_ibit)

#define GET_MBIT        (the_mbit)

#define SET_XBIT(x)     { the_xbit = x; }       

#define GET_NBIT        (the_nbit)

#define GET_PBRPC       (the_pc)

#define GET_PBR_HIGH    (the_pc & 0xff0000)

#define GET_PBR_LOW     (the_pc >> 16)

#define GET_PC          (the_pc & 0xffff)

#define GET_S           (the_s)

#define GET_VBIT        (the_vbit)

#define GET_X           (the_x)

#define GET_XBIT        (the_xbit)

#define GET_Y           (the_y)

#define GET_ZBIT        (the_zbit)

#define IFLAG           (1<<2)

#define INC_PC(x)       {the_pc += x;}

#define POP16(x)        { int _xx; POP8(x); POP8(_xx); x+= _xx<<8;}

#define POP24(x)        { int _xx; POP8(x); POP8(_xx); x += _xx << 8; POP8(_xx); x += _xx << 16; }

#define POP8(x)         { SET_S(GET_S +1); x =  fetch8(GET_S);}

#define PUSH16(x)       { int _xx = x;PUSH8(_xx >> 8); PUSH8(_xx);}

#define PUSH8(x)        { store8(GET_S, x); SET_S(GET_S-1);}

#define SET_A(x)        { the_a = x & AMASK; }

#define SET_B(x)        { the_b = x;}

#define SET_CBIT(x)     { the_cbit = x;}

#define SET_CBIT_M(x)   { the_cbit = (x & (GET_MBIT ? 0x100: 0x10000)) != 0;}

#define SET_CBIT_X(x)   { the_cbit = (x & (GET_XBIT ? 0x100: 0x10000)) != 0;}

#define SET_D(x)        {the_d = x;}

#define SET_DBIT(x)     { the_dbit= x;}

#define SET_DBR_LOW(x)  {the_dbr = (x<<16);}

#define SET_DPR(x)      { the_dpr = x;}

#define SET_E(x)        { the_e = x;}

#define SET_IBIT(x)     { the_ibit = x;}

#define SET_MBIT(x)     { the_mbit = x; }

#define SET_NBIT(x)     { the_nbit = x;}

#define SET_NBIT_16(x)  { the_nbit= ( ((x) & (0x8000)) != 0);}

#define SET_NBIT_8(x)  { the_nbit= ( ((x) & (0x80)) != 0);}

#define SET_NBIT_M(x)   { if (GET_MBIT) { SET_NBIT_8(x); } else { SET_NBIT_16(x);}}

#define SET_NBIT_X(x)   { if (GET_XBIT) { SET_NBIT_8(x); } else { SET_NBIT_16(x);}}

#define SET_PBR(x)      { the_pc = (the_pc & 0xffff) + ((x)<<16);}

#define SET_PBRPC(x)    { the_pc = x;}

#define SET_ONLY_PC(x)  { the_pc = (the_pc & 0xff0000) + ((x ) & 0xffff);}

#define SET_S(x)        {the_s = x; }

#define SET_VBIT_16(x)  {the_vbit = ((((int)x) < -0x8000) || (((int)x) > 0x7fff));}

#define SET_VBIT_8(x)   {the_vbit = ((((int)x) < -0x80) || (((int)x) > 0x7f));}

/*#define SET_VBIT_M(x)   { if(GET_MBIT) {SET_VBIT_8(x);}else {SET_VBIT_16(x);}}*/

#define SET_ZBIT_16(x)  { the_zbit = ((x & 0xffff) == 0);}

#define SET_ZBIT_8(x)   { the_zbit = ((x & 0xff) == 0);}

#define SET_ZBIT_M(x)   { if(GET_MBIT) {SET_ZBIT_8(x);}else {SET_ZBIT_16(x);}}

#define SET_ZBIT_X(x)   { if(GET_XBIT) {SET_ZBIT_8(x);}else {SET_ZBIT_16(x);}}

#define SET_VBIT(x)     { the_vbit = x; }

#define SET_ZBIT(x)     { the_zbit = x; }

#define SET_X(x)        { the_x = (x) & (GET_XBIT ? 0xff : 0xffff);}

#define SET_Y(x)        { the_y = (x) & (GET_XBIT ? 0xff : 0xffff);}

#define AMASK            ( GET_MBIT ? 0xff : 0xffff)

#define SMASK             ( GET_MBIT ? 0x80 : 0x8000)

#define SET_VBIT_M(s1,acc,d) ( the_vbit = ((s1 ^ acc) & (acc ^ d) & SMASK )!=0)

/*#define fetch8(x) (memory[x&MMASK])*/

#define fetch16(x) (fetch8(x) + (fetch8((x)+1)<<8))

#define fetch24(x) (fetch8(x) + (fetch8((x)+1)<<8) + (fetch8((x)+2)<<16))

#define fetch8sext(x) ((char)fetch8(x))

#define fetch16sext(x) ((short)fetch16(x))

#define store8(x,y) {memory[x&MMASK]=y;}

#define store16(x,y) { store8(x,y); store8(x+1,y>>8);}

#define SEXTM(x)  (GET_MBIT ? ((char)x): ((short)x))

#define STARTFUNC()     \

  register unsigned char *memory;\

  int the_s;            \

  int the_b;            \

  int the_x;            \

  int the_d;            \

  int the_y;            \

  int the_dbr;          \

  int the_pc;           \

  int the_nbit;         \

  int the_vbit;         \

  int the_z;            \

  int the_mbit;         \

  int the_ibit;         \

  int the_xbit;         \

  int the_zbit;         \

  int the_cbit;         \

  int the_dbit;         \

  int the_dpr;          \

  int the_e;            \

  int the_a;            \

  int tick_start = get_now ();\

  int cycles = 0;              \

  int insts = 0;       \

                                    \

  SET_E (saved_state.e);            \

  SET_P (saved_state.p);            \

  SET_A (saved_state.a);            \

  SET_X (saved_state.x);            \

  SET_Y (saved_state.y);            \

  SET_ONLY_PC (saved_state.pc);     \

  SET_PBR (saved_state.pc >> 16);   \

  SET_DBR_LOW (saved_state.dbr);    \

  SET_D (saved_state.d);            \

  SET_S (saved_state.s);            \

  memory = saved_state.memory ;     \

{ int k; for (k = 0; k < NFAKES; k++)       \

 store16(0x10 + k * 2, saved_state.r[k]); }\

                                    \

    top:                              \

#define ENDFUNC() \

 rethink:          \

  saved_state.ticks += get_now () - tick_start;\

  saved_state.cycles += cycles;   \

  saved_state.insts += insts;     \

{ int k; for (k = 0; k < NFAKES; k++)       \

saved_state.r[k] = fetch16(0x10 + k * 2); }\

                                  \

  saved_state.e = GET_E;          \

  saved_state.p = GET_P;          \

  saved_state.a = GET_A;          \

  saved_state.x = GET_X;          \

  saved_state.y = GET_Y;          \

  saved_state.pc = GET_PBRPC;     \

  saved_state.dbr = GET_DBR_LOW;  \

  saved_state.d = GET_D;          \

  saved_state.s = GET_S;          \

                                  \

  return 0;                        \

extern saved_state_type saved_state;

#define MMASK 0xfffff

#define NUMSEGS 16

#define RETHINK goto rethink;