home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD1.iso / Emulatoren / UAE061.LZH / uae-0.6.1 / include / newcpu.h < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-28  |  3.8 KB  |  168 lines
  1.  /* 
  2.   * UAE - The Un*x Amiga Emulator
  3.   * 
  4.   * MC68000 emulation
  5.   *
  6.   * Copyright 1995 Bernd Schmidt
  7.   */
  8.  
  9. extern int areg_byteinc[];
  10. extern int imm8_table[];
  11.  
  12. extern int broken_in;
  13.  
  14. typedef void cpuop_func(ULONG) REGPARAM;
  15.  
  16. struct cputbl {
  17.     cpuop_func *handler;
  18.     int specific;
  19.     UWORD opcode;
  20. };
  21.  
  22. extern struct cputbl smallcputbl[];
  23.  
  24. extern cpuop_func *cpufunctbl[65536];
  25. extern void op_illg(ULONG) REGPARAM;
  26.  
  27. typedef char flagtype; 
  28.  
  29. union flagu {
  30.     struct {
  31.     /* v must be at the start so that the x86 seto instruction
  32.      * changes the V flag. C must follow after V. */
  33.     char v;
  34.     char c;
  35.     char n;
  36.     char z;
  37.     } flags;
  38.     ULONG longflags;
  39. };
  40.  
  41. #define oVCNZ(F)    (8*(3-(int)&(((union flagu*)0)->flags.F)))
  42. #define VCNZ(V,C,N,Z)     ((V<<oVCNZ(v)) | (C<<oVCNZ(c)) | \
  43.              (N<<oVCNZ(n)) | (Z<<oVCNZ(z)))
  44.  
  45. extern struct regstruct 
  46. {
  47.     ULONG d[8];
  48.     CPTR  a[8],usp;
  49.     UWORD sr;
  50.     flagtype t;
  51.     flagtype s;
  52.     flagtype x;
  53.     flagtype stopped;
  54.     int intmask;
  55.     ULONG pc;
  56.     UWORD *pc_p;
  57.     UWORD *pc_oldp;
  58.     
  59.     ULONG vbr,sfc,dfc;
  60. } regs;
  61.  
  62. #ifdef INTEL_FLAG_OPT
  63. extern union flagu intel_flag_lookup[256] __asm__ ("intel_flag_lookup");
  64. extern union flagu regflags __asm__ ("regflags");
  65. #elif defined(M68K_FLAG_OPT)
  66. extern union flagu m68k_flag_lookup[16]; 
  67. extern union flagu regflags;
  68. #else
  69. extern union flagu regflags;
  70. #endif
  71.  
  72. #define ZFLG (regflags.flags.z)
  73. #define NFLG (regflags.flags.n)
  74. #define CFLG (regflags.flags.c)
  75. #define VFLG (regflags.flags.v)
  76.  
  77.  
  78. extern void MC68000_oldstep(UWORD opcode);
  79.  
  80. static __inline__ UWORD nextiword(void)
  81. {
  82.     UWORD r = *regs.pc_p++;
  83.     return r;
  84. }
  85.  
  86. static __inline__ ULONG nextilong(void)
  87. {
  88.     ULONG r = *regs.pc_p++;
  89.     r = (r << 16) + *regs.pc_p++;
  90.     return r;
  91. }
  92.  
  93. static __inline__ void m68k_setpc(CPTR newpc)
  94. {
  95.     regs.pc = newpc;
  96.     regs.pc_p = regs.pc_oldp = get_real_address(newpc);
  97. }
  98.  
  99. static __inline__ CPTR m68k_getpc(void)
  100. {
  101.     return regs.pc + ((char *)regs.pc_p - (char *)regs.pc_oldp);
  102. }
  103.  
  104. static __inline__ void m68k_setstopped(int stop)
  105. {
  106.     regs.stopped = stop;
  107.     if (stop)
  108.     specialflags |= SPCFLAG_STOP;
  109. }
  110.  
  111. static __inline__ int cctrue(const int cc)
  112. {
  113.     switch(cc){
  114.      case 0: return 1;                       /* T */
  115.      case 1: return 0;                       /* F */
  116.      case 2: return !CFLG && !ZFLG;          /* HI */
  117.      case 3: return CFLG || ZFLG;            /* LS */
  118.      case 4: return !CFLG;                   /* CC */
  119.      case 5: return CFLG;                    /* CS */
  120.      case 6: return !ZFLG;                   /* NE */
  121.      case 7: return ZFLG;                    /* EQ */
  122.      case 8: return !VFLG;                   /* VC */
  123.      case 9: return VFLG;                    /* VS */
  124.      case 10:return !NFLG;                   /* PL */
  125.      case 11:return NFLG;                    /* MI */
  126.      case 12:return NFLG == VFLG;            /* GE */
  127.      case 13:return NFLG != VFLG;            /* LT */
  128.      case 14:return !ZFLG && (NFLG == VFLG); /* GT */
  129.      case 15:return ZFLG || (NFLG != VFLG);  /* LE */
  130.     }
  131.     abort();
  132.     return 0;
  133. }
  134.  
  135. #if CPU_LEVEL > 1
  136. extern ULONG get_disp_ea (ULONG, UWORD);
  137.  
  138. #else
  139. static __inline__ ULONG get_disp_ea (ULONG base, UWORD dp)
  140. {
  141.     int reg = (dp >> 12) & 7;
  142.     LONG regd;
  143.     
  144.     if (dp & 0x8000)
  145.     regd = regs.a[reg];
  146.     else
  147.     regd = regs.d[reg];
  148.     if (!(dp & 0x800))
  149.     regd = (LONG)(WORD)regd;
  150.     return base + (BYTE)(dp) + regd;
  151. }
  152. #endif
  153.  
  154. extern void MakeSR(void);
  155. extern void MakeFromSR(void);
  156. extern void Exception(int);
  157. extern void m68k_move2c(int, ULONG *);
  158. extern void m68k_movec2(int, ULONG *);
  159. extern void m68k_divl (UWORD, ULONG, UWORD);
  160. extern void m68k_mull (UWORD, ULONG, UWORD);
  161. extern void init_m68k (void);
  162. extern void MC68000_step(void);
  163. extern void MC68000_run(void);
  164. extern void MC68000_skip(CPTR);
  165. extern void MC68000_dumpstate(CPTR *);
  166. extern void MC68000_disasm(CPTR,CPTR *,int);
  167. extern void MC68000_reset(void);
  168.