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

Diff for /np2/i286c/i286c.c between versions 1.4 and 1.19

version 1.4, 2003/10/17 12:49:52 version 1.19, 2003/12/26 03:41:05
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];  
         UINT16  *reg16_b53[256];  
         UINT16  *reg16_b20[256];  
         BYTE    szpcflag[0x200];  
         CALCEA  c_calc_ea_dst[256];  
         CALCLEA c_calc_lea[192];  
         GETLEA  c_get_ea[192];  
   
 #if !defined(CPUW2TEST)  
         BYTE    szpflag_w[0x10000];  
 #endif  #endif
   
   #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
   
 static UINT32 ea_nop(void) {  void i286c_initialize(void) {
   
         return(0);  
 }  
   
 void i286_initialize(void) {  
   
         UINT    i;          UINT    i;
         UINT    bit;          UINT    bit;
         BYTE    f;          REG8    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
         for (i=0; i<0xc0; i++) {  
                 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;  
         }          }
   #endif
   
 #if !defined(CPUW2TEST)  #if !defined(MEMOPTIMIZE)
         for (i=0; i<0x10000; i++) {          for (i=0; i<0x10000; i++) {
                 f = P_FLAG;                  f = P_FLAG;
                 for (bit=0x80; bit; bit>>=1) {                  for (bit=0x80; bit; bit>>=1) {
Line 134  void i286_initialize(void) { Line 136  void i286_initialize(void) {
                 if (i & 0x8000) {                  if (i & 0x8000) {
                         f |= S_FLAG;                          f |= S_FLAG;
                 }                  }
                 szpflag_w[i] = f;                  _szpflag16[i] = f;
         }          }
 #endif  #endif
   #if !defined(MEMOPTIMIZE) || (MEMOPTIMIZE < 2)
           i286cea_initialize();
   #endif
           v30cinit();
 }  }
   
 void i286_reset(void) {  void i286c_reset(void) {
   
         i286_initialize();          ZeroMemory(&I286_STAT, sizeof(I286_STAT));
         ZeroMemory(&i286reg, sizeof(i286reg));          I286_CS = 0xf000;
         I286_CS = 0x1fc0;          CS_BASE = 0xf0000;
         CS_BASE = 0x1fc00;          I286_IP = 0xfff0;
           I286_ADRSMASK = 0xfffff;
 }  }
   
 void i286_resetprefetch(void) {  void i286c_shut(void) {
   
           I286_MSW = 0;
   
           I286_ES = 0;
           I286_CS = 0xf000;
           I286_SS = 0;
           I286_DS = 0;
   
           ES_BASE = 0;
           CS_BASE = 0xf0000;
           SS_BASE = 0;
           DS_BASE = 0;
           SS_FIX = 0;
           DS_FIX = 0;
   
           I286_IP = 0xfff0;
           I286_ADRSMASK = 0xfffff;
 }  }
   
 void CPUCALL i286_intnum(UINT vect, UINT16 IP) {  void CPUCALL i286c_intnum(UINT vect, REG16 IP) {
   
 const BYTE      *ptr;  const BYTE      *ptr;
   
Line 161  const BYTE *ptr; Line 185  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 BYTE      *ptr;
Line 177  const BYTE *ptr; Line 201  const BYTE *ptr;
         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 200  void i286(void) { Line 224  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 237  void i286_step(void) { Line 261  void i286_step(void) {
         dmap_i286();          dmap_i286();
 }  }
   
   
   UINT32 i286c_selector(UINT sel) {
   
           I286DTR *dtr;
           UINT32  addr;
           UINT32  ret;
   
           dtr = (sel & 4)?&I286_LDTRC:&I286_GDTR;
           addr = (dtr->base24 << 16) + dtr->base + (sel & (~7));
           ret = i286_memoryread_w(addr+2);
           ret += i286_memoryread(addr+4) << 16;
           TRACEOUT(("selector idx=%x %s rpl=%d - real addr = %.6x",
                                           (sel >> 3), (sel & 4)?"LDT":"GDT", sel & 3, ret));
           return(ret);
   }
   
   
   // ---- test
   
   #if defined(I286C_TEST)
   BYTE BYTESZPF(UINT r) {
   
           if (r & (~0xff)) {
                   TRACEOUT(("BYTESZPF bound error: %x", r));
           }
           return(iflags[r & 0xff]);
   }
   
   BYTE BYTESZPCF(UINT r) {
   
           if (r & (~0x1ff)) {
                   TRACEOUT(("BYTESZPCF bound error: %x", r));
           }
           return(iflags[r & 0x1ff]);
   }
   
   BYTE WORDSZPF(UINT32 r) {
   
           BYTE    f1;
           BYTE    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);
   }
   
   BYTE WORDSZPCF(UINT32 r) {
   
           BYTE    f1;
           BYTE    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.4  
changed lines
  Added in v.1.19

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