[BACK]Return to i286c.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / i286c

Diff for /np2/i286c/i286c.c between versions 1.3 and 1.25

version 1.3, 2003/10/17 11:10:02 version 1.25, 2005/02/07 14:46:10
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        "i286.h"  #include        "cpucore.h"
 #include        "i286c.h"  #include        "i286c.h"
 #include        "memory.h"  #include        "v30patch.h"
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
 #include        "dmap.h"  #include        "dmap.h"
 #include        "i286c.mcr"  #include        "i286c.mcr"
   
   
         I286REG         i286reg;          I286CORE        i286core;
   
 const BYTE iflags[256] = {                                      // Z_FLAG, S_FLAG, P_FLAG  const UINT8 iflags[512] = {                                     // Z_FLAG, S_FLAG, P_FLAG
                         0x44, 0x00, 0x00, 0x04, 0x00, 0x04, 0x04, 0x00,                          0x44, 0x00, 0x00, 0x04, 0x00, 0x04, 0x04, 0x00,
                         0x00, 0x04, 0x04, 0x00, 0x04, 0x00, 0x00, 0x04,                          0x00, 0x04, 0x04, 0x00, 0x04, 0x00, 0x00, 0x04,
                         0x00, 0x04, 0x04, 0x00, 0x04, 0x00, 0x00, 0x04,                          0x00, 0x04, 0x04, 0x00, 0x04, 0x00, 0x00, 0x04,
Line 42  const BYTE iflags[256] = {     // Z_FLAG Line 42  const BYTE iflags[256] = {     // Z_FLAG
                         0x80, 0x84, 0x84, 0x80, 0x84, 0x80, 0x80, 0x84,                          0x80, 0x84, 0x84, 0x80, 0x84, 0x80, 0x80, 0x84,
                         0x84, 0x80, 0x80, 0x84, 0x80, 0x84, 0x84, 0x80,                          0x84, 0x80, 0x80, 0x84, 0x80, 0x84, 0x84, 0x80,
                         0x84, 0x80, 0x80, 0x84, 0x80, 0x84, 0x84, 0x80,                          0x84, 0x80, 0x80, 0x84, 0x80, 0x84, 0x84, 0x80,
                         0x80, 0x84, 0x84, 0x80, 0x84, 0x80, 0x80, 0x84};                          0x80, 0x84, 0x84, 0x80, 0x84, 0x80, 0x80, 0x84,
                           0x45, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
                           0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
                           0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
                           0x05, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
                           0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
                           0x05, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
                           0x05, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
                           0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
                           0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
                           0x05, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
                           0x05, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
                           0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
                           0x05, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
                           0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
                           0x01, 0x05, 0x05, 0x01, 0x05, 0x01, 0x01, 0x05,
                           0x05, 0x01, 0x01, 0x05, 0x01, 0x05, 0x05, 0x01,
                           0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85,
                           0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
                           0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
                           0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85,
                           0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
                           0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85,
                           0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85,
                           0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
                           0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
                           0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85,
                           0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85,
                           0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
                           0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85,
                           0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
                           0x85, 0x81, 0x81, 0x85, 0x81, 0x85, 0x85, 0x81,
                           0x81, 0x85, 0x85, 0x81, 0x85, 0x81, 0x81, 0x85};
   
   
 // ----  // ----
   
         UINT32  EA_FIX;  #if !defined(MEMOPTIMIZE)
         BYTE    *reg8_b53[256];          UINT8   _szpflag16[0x10000];
         BYTE    *reg8_b20[256];  #endif
         UINT16  *reg16_b53[256];  
         UINT16  *reg16_b20[256];  
         BYTE    szpcflag[0x200];  
         BYTE    szpflag_w[0x10000];  
         CALCEA  c_calc_ea_dst[256];  
         CALCLEA c_calc_lea[192];  
         GETLEA  c_get_ea[192];  
   
   
 static UINT32 ea_nop(void) {  
   
         return(0);  #if !defined(MEMOPTIMIZE) || (MEMOPTIMIZE < 2)
 }          UINT8   *_reg8_b53[256];
           UINT8   *_reg8_b20[256];
   #endif
   #if !defined(MEMOPTIMIZE) || (MEMOPTIMIZE < 2)
           UINT16  *_reg16_b53[256];
           UINT16  *_reg16_b20[256];
   #endif
   
 void i286_initialize(void) {  void i286c_initialize(void) {
   
   #if !defined(MEMOPTIMIZE) || (MEMOPTIMIZE < 2)
         UINT    i;          UINT    i;
         UINT    bit;  #endif
         BYTE    f;  
         int             pos;  
   
         for (i=0; i<0x100; i++) {  
                 f = P_FLAG;  
                 for (bit=0x80; bit; bit>>=1) {  
                         if (i & bit) {  
                                 f ^= P_FLAG;  
                         }  
                 }  
                 if (!(i & 0xff)) {  
                         f |= Z_FLAG;  
                 }  
                 if (i & 0x80) {  
                         f |= S_FLAG;  
                 }  
                 szpcflag[i+0x000] = f;  
                 szpcflag[i+0x100] = f | C_FLAG;  
         }  
   
   #if !defined(MEMOPTIMIZE) || (MEMOPTIMIZE < 2)
         for (i=0; i<0x100; i++) {          for (i=0; i<0x100; i++) {
                   int pos;
 #if defined(BYTESEX_LITTLE)  #if defined(BYTESEX_LITTLE)
                 pos = ((i & 0x20)?1:0);                  pos = ((i & 0x20)?1:0);
 #else  #else
                 pos = ((i & 0x20)?0:1);                  pos = ((i & 0x20)?0:1);
 #endif  #endif
                 pos += ((i >> 3) & 3) * 2;                  pos += ((i >> 3) & 3) * 2;
                 reg8_b53[i] = ((BYTE *)&I286_REG) + pos;                  _reg8_b53[i] = ((UINT8 *)&I286_REG) + pos;
 #if defined(BYTESEX_LITTLE)  #if defined(BYTESEX_LITTLE)
                 pos = ((i & 0x4)?1:0);                  pos = ((i & 0x4)?1:0);
 #else  #else
                 pos = ((i & 0x4)?0:1);                  pos = ((i & 0x4)?0:1);
 #endif  #endif
                 pos += (i & 3) * 2;                  pos += (i & 3) * 2;
                 reg8_b20[i] = ((BYTE *)&I286_REG) + pos;                  _reg8_b20[i] = ((UINT8 *)&I286_REG) + pos;
                 reg16_b53[i] = ((UINT16 *)&I286_REG) + ((i >> 3) & 7);  #if !defined(MEMOPTIMIZE) || (MEMOPTIMIZE < 2)
                 reg16_b20[i] = ((UINT16 *)&I286_REG) + (i & 7);                  _reg16_b53[i] = ((UINT16 *)&I286_REG) + ((i >> 3) & 7);
                   _reg16_b20[i] = ((UINT16 *)&I286_REG) + (i & 7);
   #endif
         }          }
   #endif
   
         for (i=0; i<0xc0; i++) {  #if !defined(MEMOPTIMIZE)
                 pos = ((i >> 3) & 0x18) + (i & 0x07);  
                 c_calc_ea_dst[i] = i286c_ea_dst_tbl[pos];  
                 c_calc_lea[i] = i286c_lea_tbl[pos];  
                 c_get_ea[i] = i286c_ea_tbl[pos];  
         }  
         for (; i<0x100; i++) {  
                 c_calc_ea_dst[i] = ea_nop;  
         }  
         for (i=0; i<0x10000; i++) {          for (i=0; i<0x10000; i++) {
                   REG8 f;
                   UINT bit;
                 f = P_FLAG;                  f = P_FLAG;
                 for (bit=0x80; bit; bit>>=1) {                  for (bit=0x80; bit; bit>>=1) {
                         if (i & bit) {                          if (i & bit) {
Line 129  void i286_initialize(void) { Line 138  void i286_initialize(void) {
                 if (i & 0x8000) {                  if (i & 0x8000) {
                         f |= S_FLAG;                          f |= S_FLAG;
                 }                  }
                 szpflag_w[i] = f;                  _szpflag16[i] = f;
           }
   #endif
   #if !defined(MEMOPTIMIZE) || (MEMOPTIMIZE < 2)
           i286cea_initialize();
   #endif
           v30cinit();
           ZeroMemory(&i286core, sizeof(i286core));
   }
   
   void i286c_deinitialize(void) {
   
           if (CPU_EXTMEM) {
                   _MFREE(CPU_EXTMEM);
                   CPU_EXTMEM = NULL;
                   CPU_EXTMEMSIZE = 0;
         }          }
 }  }
   
 void i286_reset(void) {  static void i286c_initreg(void) {
   
         i286_initialize();          I286_CS = 0xf000;
         ZeroMemory(&i286reg, sizeof(i286reg));          CS_BASE = 0xf0000;
         I286_CS = 0x1fc0;          I286_IP = 0xfff0;
         CS_BASE = 0x1fc00;          I286_ADRSMASK = 0xfffff;
 }  }
   
 void i286_resetprefetch(void) {  void i286c_reset(void) {
   
           ZeroMemory(&i286core.s, sizeof(i286core.s));
           i286c_initreg();
   }
   
   void i286c_shut(void) {
   
           ZeroMemory(&i286core.s, offsetof(I286STAT, cpu_type));
           i286c_initreg();
 }  }
   
 void CPUCALL i286_intnum(UINT vect, UINT16 IP) {  void i286c_setextsize(UINT32 size) {
   
 const BYTE      *ptr;          if (CPU_EXTMEMSIZE != size) {
                   if (CPU_EXTMEM) {
                           _MFREE(CPU_EXTMEM);
                           CPU_EXTMEM = NULL;
                   }
                   if (size) {
                           CPU_EXTMEM = (UINT8 *)_MALLOC(size + 16, "EXTMEM");
                           if (CPU_EXTMEM == NULL) {
                                   size = 0;
                           }
                   }
                   CPU_EXTMEMSIZE = size;
           }
           i286core.e.ems[0] = mem + 0xc0000;
           i286core.e.ems[1] = mem + 0xc4000;
           i286core.e.ems[2] = mem + 0xc8000;
           i286core.e.ems[3] = mem + 0xcc000;
   }
   
   void i286c_setemm(UINT frame, UINT32 addr) {
   
           UINT8   *ptr;
   
           frame &= 3;
           if (addr < USE_HIMEM) {
                   ptr = mem + addr;
           }
           else if ((addr - 0x100000 + 0x4000) <= CPU_EXTMEMSIZE) {
                   ptr = CPU_EXTMEM + (addr - 0x100000);
           }
           else {
                   ptr = mem + 0xc0000 + (frame << 14);
           }
           i286core.e.ems[frame] = ptr;
   }
   
   
   void CPUCALL i286c_intnum(UINT vect, REG16 IP) {
   
   const UINT8     *ptr;
   
         REGPUSH0(REAL_FLAGREG)          REGPUSH0(REAL_FLAGREG)
         REGPUSH0(I286_CS)          REGPUSH0(I286_CS)
Line 155  const BYTE *ptr; Line 227  const BYTE *ptr;
         I286_FLAG &= ~(T_FLAG | I_FLAG);          I286_FLAG &= ~(T_FLAG | I_FLAG);
         I286_TRAP = 0;          I286_TRAP = 0;
   
         ptr = I286_MEM + (vect * 4);          ptr = mem + (vect * 4);
         I286_IP = LOADINTELWORD(ptr+0);                         // real mode!          I286_IP = LOADINTELWORD(ptr+0);                         // real mode!
         I286_CS = LOADINTELWORD(ptr+2);                         // real mode!          I286_CS = LOADINTELWORD(ptr+2);                         // real mode!
         CS_BASE = I286_CS << 4;          CS_BASE = I286_CS << 4;
         I286_CLOCK(20)          I286_WORKCLOCK(20);
 }  }
   
 void CPUCALL i286_interrupt(BYTE vect) {  void CPUCALL i286c_interrupt(REG8 vect) {
   
         UINT    op;          UINT    op;
 const BYTE      *ptr;  const UINT8     *ptr;
   
         op = i286_memoryread(I286_IP + CS_BASE);          op = i286_memoryread(I286_IP + CS_BASE);
         if (op == 0xf4) {                                                       // hlt          if (op == 0xf4) {                                                       // hlt
                 I286_IP++;                  I286_IP++;
         }          }
         REGPUSH0(REAL_FLAGREG)          REGPUSH0(REAL_FLAGREG)                                          // ここV30で辻褄が合わない
         REGPUSH0(I286_CS)          REGPUSH0(I286_CS)
         REGPUSH0(I286_IP)          REGPUSH0(I286_IP)
   
         I286_FLAG &= ~(T_FLAG | I_FLAG);          I286_FLAG &= ~(T_FLAG | I_FLAG);
         I286_TRAP = 0;          I286_TRAP = 0;
   
         ptr = I286_MEM + (vect * 4);          ptr = mem + (vect * 4);
         I286_IP = LOADINTELWORD(ptr+0);                         // real mode!          I286_IP = LOADINTELWORD(ptr + 0);                       // real mode!
         I286_CS = LOADINTELWORD(ptr+2);                         // real mode!          I286_CS = LOADINTELWORD(ptr + 2);                       // real mode!
         CS_BASE = I286_CS << 4;          CS_BASE = I286_CS << 4;
         I286_CLOCK(20)          I286_WORKCLOCK(20);
 }  }
   
 void i286(void) {  void i286c(void) {
   
         UINT    opcode;          UINT    opcode;
   
Line 194  void i286(void) { Line 266  void i286(void) {
                         GET_PCBYTE(opcode);                          GET_PCBYTE(opcode);
                         i286op[opcode]();                          i286op[opcode]();
                         if (I286_TRAP) {                          if (I286_TRAP) {
                                 i286_interrupt(1);                                  i286c_interrupt(1);
                         }                          }
                         dmap_i286();                          dmap_i286();
                 } while(nevent.remainclock > 0);                  } while(I286_REMCLOCK > 0);
         }          }
         else if (dmac.working) {          else if (dmac.working) {
                 do {                  do {
                         GET_PCBYTE(opcode);                          GET_PCBYTE(opcode);
                         i286op[opcode]();                          i286op[opcode]();
                         dmap_i286();                          dmap_i286();
                 } while(nevent.remainclock > 0);                  } while(I286_REMCLOCK > 0);
         }          }
         else {          else {
                 do {                  do {
                         GET_PCBYTE(opcode);                          GET_PCBYTE(opcode);
                         i286op[opcode]();                          i286op[opcode]();
                 } while(nevent.remainclock > 0);                  } while(I286_REMCLOCK > 0);
         }          }
 }  }
   
 void i286_step(void) {  void i286c_step(void) {
   
         UINT    opcode;          UINT    opcode;
   
Line 231  void i286_step(void) { Line 303  void i286_step(void) {
         dmap_i286();          dmap_i286();
 }  }
   
   
   // ---- test
   
   #if defined(I286C_TEST)
   UINT8 BYTESZPF(UINT r) {
   
           if (r & (~0xff)) {
                   TRACEOUT(("BYTESZPF bound error: %x", r));
           }
           return(iflags[r & 0xff]);
   }
   
   UINT8 BYTESZPCF(UINT r) {
   
           if (r & (~0x1ff)) {
                   TRACEOUT(("BYTESZPCF bound error: %x", r));
           }
           return(iflags[r & 0x1ff]);
   }
   
   UINT8 WORDSZPF(UINT32 r) {
   
           UINT8   f1;
           UINT8   f2;
   
           if (r & (~0xffff)) {
                   TRACEOUT(("WORDSZPF bound error: %x", r));
           }
           f1 = _szpflag16[r & 0xffff];
           f2 = iflags[r & 0xff] & P_FLAG;
           f2 += (r)?0:Z_FLAG;
           f2 += (r >> 8) & S_FLAG;
           if (f1 != f2) {
                   TRACEOUT(("word flag error: %.2x %.2x", f1, f2));
           }
           return(f1);
   }
   
   UINT8 WORDSZPCF(UINT32 r) {
   
           UINT8   f1;
           UINT8   f2;
   
           if ((r & 0xffff0000) && (!(r & 0x00010000))) {
                   TRACEOUT(("WORDSZPCF bound error: %x", r));
           }
           f1 = (r >> 16) & 1;
           f1 += _szpflag16[LOW16(r)];
   
           f2 = iflags[r & 0xff] & P_FLAG;
           f2 += (LOW16(r))?0:Z_FLAG;
           f2 += (r >> 8) & S_FLAG;
           f2 += (r >> 16) & 1;
   
           if (f1 != f2) {
                   TRACEOUT(("word flag error: %.2x %.2x", f1, f2));
           }
           return(f1);
   }
   #endif
   
Removed from v.1.3  
changed lines
  Added in v.1.25

RetroPC.NET-CVS <cvs@retropc.net>