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

Diff for /np2/i386c/ia32/cpu_mem.c between versions 1.7 and 1.10

version 1.7, 2004/01/25 07:53:08 version 1.10, 2004/02/05 16:41:32
Line 31 Line 31
 #include "cpu.h"  #include "cpu.h"
 #include "memory.h"  #include "memory.h"
   
 // static BYTE *cpumem = 0;  
 // static DWORD extmem_size = 0;  
   
 #define cpumem          i386core.e.ext  
 #define extmem_size     i386core.e.extsize  
   
   
 /*  
  * initialize 1MB-16MB memory  
  */  
   
 int  
 init_cpumem(UINT8 usemem)  
 {  
         UINT32  size;  
   
         size = usemem << 20;  
         if (size >= (LOWMEM - 0x100000)) {  
                 size -= (LOWMEM - 0x100000);  
         }  
         else {  
                 size = 0;  
         }  
         if (extmem_size != size) {  
                 if (cpumem) {  
                         free(cpumem);  
                         cpumem = 0;  
                 }  
                 if (size) {  
                         cpumem = (BYTE *)malloc(size);  
                         if (cpumem == NULL) {  
                                 size = 0;  
                         }  
                 }  
                 extmem_size = size;  
         }  
         return SUCCESS;  
 }  
   
   
 /*  /*
  * memory access check   * memory access check
Line 270  cpu_stack_pop_check(descriptor_t* sdp, D Line 231  cpu_stack_pop_check(descriptor_t* sdp, D
 }  }
   
   
 #define AS32_NOCHECK  
 #undef  OVERRUN_CHECK  
   
 #if defined(OVERRUN_CHECK)  
 #define OVERRUN_EXCEPTION()     EXCEPTION(GP_EXCEPTION, 0)  
 #else  
 #define OVERRUN_EXCEPTION()  
 #endif  
   
 /*  /*
  * code fetch   * code fetch
  */   */
Line 289  cpu_codefetch(DWORD offset) Line 241  cpu_codefetch(DWORD offset)
         DWORD addr;          DWORD addr;
   
         sd = &CPU_STAT_SREG(CPU_CS_INDEX);          sd = &CPU_STAT_SREG(CPU_CS_INDEX);
 #ifndef AS32_NOCHECK  
         if (!CPU_INST_AS32)  
                 offset &= 0xffff;  
 #endif  
         if (offset <= sd->u.seg.limit) {          if (offset <= sd->u.seg.limit) {
                 addr = CPU_STAT_SREGBASE(CPU_CS_INDEX) + offset;                  addr = CPU_STAT_SREGBASE(CPU_CS_INDEX) + offset;
                 if (!CPU_STAT_PM)                  if (!CPU_STAT_PM)
Line 310  cpu_codefetch_w(DWORD offset) Line 258  cpu_codefetch_w(DWORD offset)
         DWORD addr;          DWORD addr;
   
         sd = &CPU_STAT_SREG(CPU_CS_INDEX);          sd = &CPU_STAT_SREG(CPU_CS_INDEX);
 #ifndef AS32_NOCHECK  
         if (!CPU_INST_AS32)  
                 offset &= 0xffff;  
 #endif  
         if (offset <= sd->u.seg.limit - 1) {          if (offset <= sd->u.seg.limit - 1) {
                 addr = CPU_STAT_SREGBASE(CPU_CS_INDEX) + offset;                  addr = CPU_STAT_SREGBASE(CPU_CS_INDEX) + offset;
                 if (!CPU_STAT_PM)                  if (!CPU_STAT_PM)
Line 331  cpu_codefetch_d(DWORD offset) Line 275  cpu_codefetch_d(DWORD offset)
         DWORD addr;          DWORD addr;
   
         sd = &CPU_STAT_SREG(CPU_CS_INDEX);          sd = &CPU_STAT_SREG(CPU_CS_INDEX);
 #ifndef AS32_NOCHECK  
         if (!CPU_INST_AS32)  
                 offset &= 0xffff;  
 #endif  
         if (offset <= sd->u.seg.limit - 3) {          if (offset <= sd->u.seg.limit - 3) {
                 addr = CPU_STAT_SREGBASE(CPU_CS_INDEX) + offset;                  addr = CPU_STAT_SREGBASE(CPU_CS_INDEX) + offset;
                 if (!CPU_STAT_PM)                  if (!CPU_STAT_PM)
Line 364  cpu_vmemoryread(int idx, DWORD offset) Line 304  cpu_vmemoryread(int idx, DWORD offset)
                 goto err;                  goto err;
         }          }
   
 #ifndef AS32_NOCHECK  
         if (!CPU_INST_AS32)  
                 offset &= 0xffff;  
 #endif  
         if (!(sd->flag & CPU_DESC_FLAG_READABLE)) {          if (!(sd->flag & CPU_DESC_FLAG_READABLE)) {
                 cpu_memoryread_check(sd, offset, 1,                  cpu_memoryread_check(sd, offset, 1,
                     (idx == CPU_SS_INDEX) ? SS_EXCEPTION : GP_EXCEPTION);                      (idx == CPU_SS_INDEX) ? SS_EXCEPTION : GP_EXCEPTION);
Line 397  cpu_vmemoryread(int idx, DWORD offset) Line 333  cpu_vmemoryread(int idx, DWORD offset)
         addr = CPU_STAT_SREGBASE(idx) + offset;          addr = CPU_STAT_SREGBASE(idx) + offset;
         if (!CPU_STAT_PM)          if (!CPU_STAT_PM)
                 return cpu_memoryread(addr);                  return cpu_memoryread(addr);
         return cpu_lmemoryread(addr);          return cpu_lmemoryread(addr, CPU_STAT_USER_MODE);
   
 err:  err:
         EXCEPTION(exc, 0);          EXCEPTION(exc, 0);
Line 419  cpu_vmemoryread_w(int idx, DWORD offset) Line 355  cpu_vmemoryread_w(int idx, DWORD offset)
                 goto err;                  goto err;
         }          }
   
 #ifndef AS32_NOCHECK  
         if (!CPU_INST_AS32)  
                 offset &= 0xffff;  
 #endif  
         if (!(sd->flag & CPU_DESC_FLAG_READABLE)) {          if (!(sd->flag & CPU_DESC_FLAG_READABLE)) {
                 cpu_memoryread_check(sd, offset, 2,                  cpu_memoryread_check(sd, offset, 2,
                     (idx == CPU_SS_INDEX) ? SS_EXCEPTION : GP_EXCEPTION);                      (idx == CPU_SS_INDEX) ? SS_EXCEPTION : GP_EXCEPTION);
Line 452  cpu_vmemoryread_w(int idx, DWORD offset) Line 384  cpu_vmemoryread_w(int idx, DWORD offset)
         addr = CPU_STAT_SREGBASE(idx) + offset;          addr = CPU_STAT_SREGBASE(idx) + offset;
         if (!CPU_STAT_PM)          if (!CPU_STAT_PM)
                 return cpu_memoryread_w(addr);                  return cpu_memoryread_w(addr);
         return cpu_lmemoryread_w(addr);          return cpu_lmemoryread_w(addr, CPU_STAT_USER_MODE);
   
 err:  err:
         EXCEPTION(exc, 0);          EXCEPTION(exc, 0);
Line 474  cpu_vmemoryread_d(int idx, DWORD offset) Line 406  cpu_vmemoryread_d(int idx, DWORD offset)
                 goto err;                  goto err;
         }          }
   
 #ifndef AS32_NOCHECK  
         if (!CPU_INST_AS32)  
                 offset &= 0xffff;  
 #endif  
         if (!(sd->flag & CPU_DESC_FLAG_READABLE)) {          if (!(sd->flag & CPU_DESC_FLAG_READABLE)) {
                 cpu_memoryread_check(sd, offset, 4,                  cpu_memoryread_check(sd, offset, 4,
                     (idx == CPU_SS_INDEX) ? SS_EXCEPTION : GP_EXCEPTION);                      (idx == CPU_SS_INDEX) ? SS_EXCEPTION : GP_EXCEPTION);
Line 507  cpu_vmemoryread_d(int idx, DWORD offset) Line 435  cpu_vmemoryread_d(int idx, DWORD offset)
         addr = CPU_STAT_SREGBASE(idx) + offset;          addr = CPU_STAT_SREGBASE(idx) + offset;
         if (!CPU_STAT_PM)          if (!CPU_STAT_PM)
                 return cpu_memoryread_d(addr);                  return cpu_memoryread_d(addr);
         return cpu_lmemoryread_d(addr);          return cpu_lmemoryread_d(addr, CPU_STAT_USER_MODE);
   
 err:  err:
         EXCEPTION(exc, 0);          EXCEPTION(exc, 0);
Line 530  cpu_vmemorywrite(int idx, DWORD offset,  Line 458  cpu_vmemorywrite(int idx, DWORD offset, 
                 goto err;                  goto err;
         }          }
   
 #ifndef AS32_NOCHECK  
         if (!CPU_INST_AS32)  
                 offset &= 0xffff;  
 #endif  
         if (!(sd->flag & CPU_DESC_FLAG_WRITABLE)) {          if (!(sd->flag & CPU_DESC_FLAG_WRITABLE)) {
                 cpu_memorywrite_check(sd, offset, 1,                  cpu_memorywrite_check(sd, offset, 1,
                     (idx == CPU_SS_INDEX) ? SS_EXCEPTION : GP_EXCEPTION);                      (idx == CPU_SS_INDEX) ? SS_EXCEPTION : GP_EXCEPTION);
Line 566  cpu_vmemorywrite(int idx, DWORD offset,  Line 490  cpu_vmemorywrite(int idx, DWORD offset, 
                 cpu_memorywrite(addr, val);                  cpu_memorywrite(addr, val);
         } else {          } else {
                 /* protected mode */                  /* protected mode */
                 cpu_lmemorywrite(addr, val);                  cpu_lmemorywrite(addr, val, CPU_STAT_USER_MODE);
         }          }
         return;          return;
   
Line 589  cpu_vmemorywrite_w(int idx, DWORD offset Line 513  cpu_vmemorywrite_w(int idx, DWORD offset
                 goto err;                  goto err;
         }          }
   
 #ifndef AS32_NOCHECK  
         if (!CPU_INST_AS32)  
                 offset &= 0xffff;  
 #endif  
         if (!(sd->flag & CPU_DESC_FLAG_WRITABLE)) {          if (!(sd->flag & CPU_DESC_FLAG_WRITABLE)) {
                 cpu_memorywrite_check(sd, offset, 2,                  cpu_memorywrite_check(sd, offset, 2,
                     (idx == CPU_SS_INDEX) ? SS_EXCEPTION : GP_EXCEPTION);                      (idx == CPU_SS_INDEX) ? SS_EXCEPTION : GP_EXCEPTION);
Line 625  cpu_vmemorywrite_w(int idx, DWORD offset Line 545  cpu_vmemorywrite_w(int idx, DWORD offset
                 cpu_memorywrite_w(addr, val);                  cpu_memorywrite_w(addr, val);
         } else {          } else {
                 /* protected mode */                  /* protected mode */
                 cpu_lmemorywrite_w(addr, val);                  cpu_lmemorywrite_w(addr, val, CPU_STAT_USER_MODE);
         }          }
         return;          return;
   
Line 648  cpu_vmemorywrite_d(int idx, DWORD offset Line 568  cpu_vmemorywrite_d(int idx, DWORD offset
                 goto err;                  goto err;
         }          }
   
 #ifndef AS32_NOCHECK  
         if (!CPU_INST_AS32)  
                 offset &= 0xffff;  
 #endif  
         if (!(sd->flag & CPU_DESC_FLAG_WRITABLE)) {          if (!(sd->flag & CPU_DESC_FLAG_WRITABLE)) {
                 cpu_memorywrite_check(sd, offset, 4,                  cpu_memorywrite_check(sd, offset, 4,
                     (idx == CPU_SS_INDEX) ? SS_EXCEPTION : GP_EXCEPTION);                      (idx == CPU_SS_INDEX) ? SS_EXCEPTION : GP_EXCEPTION);
Line 684  cpu_vmemorywrite_d(int idx, DWORD offset Line 600  cpu_vmemorywrite_d(int idx, DWORD offset
                 cpu_memorywrite_d(addr, val);                  cpu_memorywrite_d(addr, val);
         } else {          } else {
                 /* protected mode */                  /* protected mode */
                 cpu_lmemorywrite_d(addr, val);                  cpu_lmemorywrite_d(addr, val, CPU_STAT_USER_MODE);
         }          }
         return;          return;
   
 err:  err:
         EXCEPTION(exc, 0);          EXCEPTION(exc, 0);
 }  }
   
 /*  
  * physical address memory function  
  */  
 void MEMCALL  
 cpu_memorywrite_d(DWORD address, DWORD value)  
 {  
         DWORD adr = address & CPU_STAT_ADRSMASK;  
         DWORD diff;  
         DWORD off;  
   
         if (adr < LOWMEM - 3) {  
                 __i286_memorywrite_d(adr, value);  
         } else if (adr < LOWMEM) {  
                 diff = LOWMEM - adr;  
   
                 switch (diff) {  
                 default:  
                         ia32_panic("cpu_memorywrite_d: diff(%d)", diff);  
                         break;  
   
                 case 3:  
                         __i286_memorywrite_w(adr, value & 0xffff);  
                         value >>= 16;  
                         __i286_memorywrite(adr + 2, value & 0xff);  
                         value >>= 8;  
                         break;  
   
                 case 2:  
                         __i286_memorywrite_w(adr, value & 0xffff);  
                         value >>= 16;  
                         break;  
   
                 case 1:  
                         __i286_memorywrite(adr, value & 0xff);  
                         value >>= 8;  
                         break;  
                 }  
   
                 if (extmem_size > 0) {  
                         off = 0;  
   
                         switch (4 - diff) {  
                         case 3:  
                                 cpumem[off++] = value & 0xff;  
                                 value >>= 8;  
                                 if (off >= extmem_size) {  
                                         OVERRUN_EXCEPTION();  
                                         break;  
                                 }  
                                 /*FALLTHROUGH*/  
                         case 2:  
                                 cpumem[off++] = value & 0xff;  
                                 if (off >= extmem_size) {  
                                         OVERRUN_EXCEPTION();  
                                         break;  
                                 }  
                                 value >>= 8;  
                                 /*FALLTHROUGH*/  
                         case 1:  
                                 cpumem[off] = value & 0xff;  
                                 break;  
                         }  
                 } else {  
                         OVERRUN_EXCEPTION();  
                 }  
         } else if (extmem_size > 0) {  
                 adr -= LOWMEM;  
                 if (adr < extmem_size - 3) {  
                         STOREINTELDWORD(cpumem + adr, value);  
                 } else if (adr < extmem_size) {  
                         diff = extmem_size - adr;  
                         value >>= (8 * (4 - diff));  
   
                         switch (diff) {  
                         default:  
                                 ia32_panic("cpu_memorywrite_d: diff(%d)", diff);  
                                 break;  
   
                         case 3:  
                                 cpumem[extmem_size - 3] = value & 0xff;  
                                 value >>= 8;  
                                 /*FALLTHROUGH*/  
                         case 2:  
                                 cpumem[extmem_size - 2] = value & 0xff;  
                                 value >>= 8;  
                                 /*FALLTHROUGH*/  
                         case 1:  
                                 cpumem[extmem_size - 1] = value & 0xff;  
                                 break;  
                         }  
                         OVERRUN_EXCEPTION();  
                 } else {  
                         OVERRUN_EXCEPTION();  
                 }  
         } else {  
                 OVERRUN_EXCEPTION();  
         }  
 }  
   
 void MEMCALL  
 cpu_memorywrite_w(DWORD address, WORD value)  
 {  
         DWORD adr = address & CPU_STAT_ADRSMASK;  
   
         if (adr < LOWMEM - 1) {  
                 __i286_memorywrite_w(adr, value);  
         } else if (adr < LOWMEM) {  
                 __i286_memorywrite(adr, value & 0xff);  
                 cpumem[adr - (LOWMEM - 1)] = (value >> 8) & 0xff;  
         } else if (extmem_size > 0) {  
                 adr -= LOWMEM;  
                 if (adr < extmem_size - 1) {  
                         STOREINTELWORD(cpumem + adr, value);  
                 } else if (adr == extmem_size - 1) {  
                         cpumem[adr] = value & 0xff;  
                         OVERRUN_EXCEPTION();  
                 } else {  
                         OVERRUN_EXCEPTION();  
                 }  
         } else {  
                 OVERRUN_EXCEPTION();  
         }  
 }  
   
 void MEMCALL  
 cpu_memorywrite(DWORD address, BYTE value)  
 {  
         DWORD adr = address & CPU_STAT_ADRSMASK;  
   
         if (adr < LOWMEM) {  
                 __i286_memorywrite(adr, value);  
         } else if (extmem_size > 0) {  
                 adr -= LOWMEM;  
                 if (adr < extmem_size) {  
                         cpumem[adr] = value;  
                 } else {  
                         OVERRUN_EXCEPTION();  
                 }  
         } else {  
                 OVERRUN_EXCEPTION();  
         }  
 }  
   
 DWORD MEMCALL  
 cpu_memoryread_d(DWORD address)  
 {  
         DWORD adr = address & CPU_STAT_ADRSMASK;  
         DWORD val;  
         DWORD diff;  
   
         if (adr < LOWMEM - 3) {  
                 val = __i286_memoryread_d(adr);  
         } else if (adr < LOWMEM) {  
                 diff = LOWMEM - adr;  
   
                 switch (diff) {  
                 default:  
                         ia32_panic("cpu_memoryread_d: diff(%d)", diff);  
                         val = 0;        /* compiler happy */  
                         break;  
   
                 case 3:  
                         val = __i286_memoryread_w(adr);  
                         val |= __i286_memoryread(adr + 2);  
                         if (extmem_size > 0) {  
                                 val |= cpumem[0] << 24;  
                         } else {  
                                 val |= 0xff000000;  
                                 OVERRUN_EXCEPTION();  
                         }  
                         break;  
   
                 case 2:  
                         val = __i286_memoryread_w(adr);  
                         if (extmem_size > 1) {  
                                 val |= (DWORD)LOADINTELWORD(cpumem) << 16;  
                         } else {  
                                 val |= 0xffff0000;  
                                 OVERRUN_EXCEPTION();  
                         }  
                         break;  
   
                 case 1:  
                         val = __i286_memoryread(adr);  
                         if (extmem_size > 2) {  
                                 val |= (DWORD)LOADINTELWORD(cpumem) << 8;  
                                 val |= (DWORD)cpumem[2] << 24;  
                         } else {  
                                 val |= 0xffffff00;  
                                 OVERRUN_EXCEPTION();  
                         }  
                         break;  
                 }  
         } else if (extmem_size > 0) {  
                 adr -= LOWMEM;  
                 if (adr < extmem_size - 3) {  
                         val = LOADINTELDWORD(cpumem + adr);  
                 } else if (adr < extmem_size) {  
                         diff = extmem_size - adr;  
                         val = 0;  
   
                         switch (diff) {  
                         default:  
                                 ia32_panic("cpu_memoryread_d: diff(%d)", diff);  
                                 break;  
   
                         case 3:  
                                 val |= cpumem[extmem_size - 3];  
                                 /*FALLTHROUGH*/  
                         case 2:  
                                 val |= (cpumem[extmem_size - 2] << (8 * (diff - 2)));  
                                 /*FALLTHROUGH*/  
                         case 1:  
                                 val |= (cpumem[extmem_size - 1] << (8 * (diff - 1)));  
                                 break;  
                         }  
                         val |= ((DWORD)-1) << (8 * diff);  
                         OVERRUN_EXCEPTION();  
                 } else {  
                         val = (DWORD)-1;  
                         OVERRUN_EXCEPTION();  
                 }  
         } else {  
                 val = (DWORD)-1;  
                 OVERRUN_EXCEPTION();  
         }  
         return val;  
 }  
   
 WORD MEMCALL  
 cpu_memoryread_w(DWORD address)  
 {  
         DWORD adr = address & CPU_STAT_ADRSMASK;  
         WORD val;  
   
         if (adr < LOWMEM - 1) {  
                 val = __i286_memoryread_w(adr);  
         } else if (adr < LOWMEM) {  
                 val = __i286_memoryread(adr);  
                 val |= (WORD)cpumem[0] << 8;  
         } else if (extmem_size > 0) {  
                 adr -= LOWMEM;  
                 if (adr < extmem_size - 1) {  
                         val = LOADINTELWORD(cpumem + adr);  
                 } else if (adr == extmem_size - 1) {  
                         val = 0xff00 | cpumem[adr];  
                         OVERRUN_EXCEPTION();  
                 } else {  
                         val = (WORD)-1;  
                         OVERRUN_EXCEPTION();  
                 }  
         } else {  
                 val = (WORD)-1;  
                 OVERRUN_EXCEPTION();  
         }  
         return val;  
 }  
   
 BYTE MEMCALL  
 cpu_memoryread(DWORD address)  
 {  
         DWORD adr = address & CPU_STAT_ADRSMASK;  
         BYTE val;  
   
         if (adr < LOWMEM) {  
                 val = __i286_memoryread(adr);  
         } else if (extmem_size > 0) {  
                 adr -= LOWMEM;  
                 if (adr < extmem_size) {  
                         val = cpumem[adr];  
                 } else {  
                         val = (BYTE)-1;  
                         OVERRUN_EXCEPTION();  
                 }  
         } else {  
                 val = (BYTE)-1;  
                 OVERRUN_EXCEPTION();  
         }  
         return val;  
 }  
Removed from v.1.7  
changed lines
  Added in v.1.10

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