[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.1 and 1.5

version 1.1, 2003/12/08 00:55:31 version 1.5, 2004/01/13 16:32:16
Line 31 Line 31
 #include "cpu.h"  #include "cpu.h"
 #include "memory.h"  #include "memory.h"
   
 // ¤¢¤È¤Ç¡Ä  
 extern DWORD cpumem_addrmask;  
   
 BYTE *cpumem = 0;  BYTE *cpumem = 0;
 DWORD extmem_size = 0;  DWORD extmem_size = 0;
 BYTE protectmem_size = 0;  BYTE protectmem_size = 0;
   
   
 /*  /*
  * initialize 1MB-16MB memory   * initialize 1MB-16MB memory
  */   */
Line 56  init_cpumem(BYTE usemem) Line 54  init_cpumem(BYTE usemem)
                         free(cpumem);                          free(cpumem);
                         cpumem = 0;                          cpumem = 0;
                 }                  }
   
                 if (size <= LOWMEM - 0x100000) {                  if (size <= LOWMEM - 0x100000) {
                         extmem_size = 0;                          extmem_size = 0;
                         cpumem = 0;                          cpumem = 0;
                 } else {                  } else {
                         extmem_size = size - (LOWMEM - 0x100000);                          extmem_size = size - (LOWMEM - 0x100000);
                         cpumem = (BYTE*)malloc(extmem_size);                          cpumem = (BYTE *)malloc(extmem_size);
                         if (cpumem == NULL) {                          if (cpumem == NULL) {
                                 protectmem_size = 0;                                  protectmem_size = 0;
                                 return FAILURE;                                  return FAILURE;
                         }                          }
                           memset(cpumem, 0, extmem_size);
                 }                  }
         }          }
   
         if (cpumem)  
                 memset(cpumem, 0, extmem_size);  
   
         protectmem_size = usemem;          protectmem_size = usemem;
         return SUCCESS;          return SUCCESS;
 }  }
Line 85  void Line 79  void
 cpu_memoryread_check(descriptor_t* sd, DWORD madr, DWORD length, int e)  cpu_memoryread_check(descriptor_t* sd, DWORD madr, DWORD length, int e)
 {  {
   
         if (!CPU_STAT_PM) {          if (CPU_STAT_PM) {
                 if ((madr > sd->u.seg.segend - length + 1)  
                     || (length - 1 > sd->u.seg.limit)) {  
                         EXCEPTION(e, 0);  
                 }  
         } else {  
                 /* invalid */                  /* invalid */
                 if (!sd->valid) {                  if (!sd->valid) {
                         EXCEPTION(GP_EXCEPTION, 0);                          EXCEPTION(GP_EXCEPTION, 0);
Line 129  cpu_memoryread_check(descriptor_t* sd, D Line 118  cpu_memoryread_check(descriptor_t* sd, D
                         break;                          break;
                 }                  }
         }          }
 #if 0   /* XXX */  
         sd->flag |= CPU_DESC_READABLE;          sd->flag |= CPU_DESC_READABLE;
 #endif  
 }  }
   
 void  void
 cpu_memorywrite_check(descriptor_t* sd, DWORD madr, DWORD length, int e)  cpu_memorywrite_check(descriptor_t* sd, DWORD madr, DWORD length, int e)
 {  {
   
         if (!CPU_STAT_PM) {          if (CPU_STAT_PM) {
                 if ((madr > sd->u.seg.segend - length + 1)  
                     || (length - 1 > sd->u.seg.limit)) {  
                         EXCEPTION(e, 0);  
                 }  
         } else {  
                 /* invalid */                  /* invalid */
                 if (!sd->valid) {                  if (!sd->valid) {
                         EXCEPTION(GP_EXCEPTION, 0);                          EXCEPTION(GP_EXCEPTION, 0);
Line 178  cpu_memorywrite_check(descriptor_t* sd,  Line 160  cpu_memorywrite_check(descriptor_t* sd, 
                         break;                          break;
                 }                  }
         }          }
 #if 0   /* XXX */  
         sd->flag |= CPU_DESC_WRITABLE;          sd->flag |= CPU_DESC_WRITABLE;
 #endif  
 }  }
   
 BOOL  BOOL
Line 287  cpu_codefetch_w(DWORD madr) Line 267  cpu_codefetch_w(DWORD madr)
         DWORD addr;          DWORD addr;
   
         sd = &CPU_STAT_SREG(CPU_CS_INDEX);          sd = &CPU_STAT_SREG(CPU_CS_INDEX);
   
         if (!CPU_INST_AS32)          if (!CPU_INST_AS32)
                 madr &= 0xffff;                  madr &= 0xffff;
         if (madr <= sd->u.seg.segend) {          if (madr <= sd->u.seg.segend - 1) {
                 addr = CPU_STAT_SREGBASE(CPU_CS_INDEX) + madr;                  addr = CPU_STAT_SREGBASE(CPU_CS_INDEX) + madr;
                 if (!CPU_STAT_PM)                  if (!CPU_STAT_PM)
                         return cpu_memoryread_w(addr);                          return cpu_memoryread_w(addr);
Line 309  cpu_codefetch_d(DWORD madr) Line 288  cpu_codefetch_d(DWORD madr)
         sd = &CPU_STAT_SREG(CPU_CS_INDEX);          sd = &CPU_STAT_SREG(CPU_CS_INDEX);
         if (!CPU_INST_AS32)          if (!CPU_INST_AS32)
                 madr &= 0xffff;                  madr &= 0xffff;
         if (madr <= sd->u.seg.segend) {          if (madr <= sd->u.seg.segend - 3) {
                 addr = CPU_STAT_SREGBASE(CPU_CS_INDEX) + madr;                  addr = CPU_STAT_SREGBASE(CPU_CS_INDEX) + madr;
                 if (!CPU_STAT_PM)                  if (!CPU_STAT_PM)
                         return cpu_memoryread_d(addr);                          return cpu_memoryread_d(addr);
Line 519  cpu_vmemorywrite_d(int idx, DWORD madr,  Line 498  cpu_vmemorywrite_d(int idx, DWORD madr, 
 void MEMCALL  void MEMCALL
 cpu_memorywrite_d(DWORD address, DWORD value)  cpu_memorywrite_d(DWORD address, DWORD value)
 {  {
         DWORD adr = address & cpumem_addrmask;          DWORD adr = address & CPU_STAT_ADRSMASK;
   
         if (adr < LOWMEM - 3) {          if (adr < LOWMEM - 3) {
                 __i286_memorywrite_d(adr, value);                  __i286_memorywrite_d(adr, value);
Line 528  cpu_memorywrite_d(DWORD address, DWORD v Line 507  cpu_memorywrite_d(DWORD address, DWORD v
                 cpu_memorywrite_w(adr + 2, (value >> 16) & 0xffff);                  cpu_memorywrite_w(adr + 2, (value >> 16) & 0xffff);
         } else {          } else {
                 adr -= LOWMEM;                  adr -= LOWMEM;
                 if (adr < extmem_size) {                  if (adr < extmem_size - 3) {
                         SETDWORD(cpumem + adr, value);                          STOREINTELDWORD(cpumem + adr, value);
                 } else {                  } else if (adr < extmem_size) {
                         ia32_panic("cpu_memorywrite_d: out of universe.");                          cpu_memorywrite_w(adr, value & 0xffff);
                           cpu_memorywrite_w(adr + 2, (value >> 16) & 0xffff);
                 }                  }
         }          }
 }  }
Line 539  cpu_memorywrite_d(DWORD address, DWORD v Line 519  cpu_memorywrite_d(DWORD address, DWORD v
 void MEMCALL  void MEMCALL
 cpu_memorywrite_w(DWORD address, WORD value)  cpu_memorywrite_w(DWORD address, WORD value)
 {  {
         DWORD adr = address & cpumem_addrmask;          DWORD adr = address & CPU_STAT_ADRSMASK;
   
         if (adr < LOWMEM - 1) {          if (adr < LOWMEM - 1) {
                 __i286_memorywrite_w(adr, value);                  __i286_memorywrite_w(adr, value);
Line 548  cpu_memorywrite_w(DWORD address, WORD va Line 528  cpu_memorywrite_w(DWORD address, WORD va
                 cpumem[adr - (LOWMEM - 1)] = (value >> 8) & 0xff;                  cpumem[adr - (LOWMEM - 1)] = (value >> 8) & 0xff;
         } else {          } else {
                 adr -= LOWMEM;                  adr -= LOWMEM;
                 if (adr < extmem_size) {                  if (adr < extmem_size - 1) {
                         SETWORD(cpumem + adr, value);                          STOREINTELWORD(cpumem + adr, value);
                 } else {                  } else if (adr == extmem_size - 1) {
                         ia32_panic("cpu_memorywrite_w: out of universe.");                          cpumem[adr] = value & 0xff;
                 }                  }
         }          }
 }  }
Line 559  cpu_memorywrite_w(DWORD address, WORD va Line 539  cpu_memorywrite_w(DWORD address, WORD va
 void MEMCALL  void MEMCALL
 cpu_memorywrite(DWORD address, BYTE value)  cpu_memorywrite(DWORD address, BYTE value)
 {  {
         DWORD adr = address & cpumem_addrmask;          DWORD adr = address & CPU_STAT_ADRSMASK;
   
         if (adr < LOWMEM) {          if (adr < LOWMEM) {
                 __i286_memorywrite(adr, value);                  __i286_memorywrite(adr, value);
Line 567  cpu_memorywrite(DWORD address, BYTE valu Line 547  cpu_memorywrite(DWORD address, BYTE valu
                 adr -= LOWMEM;                  adr -= LOWMEM;
                 if (adr < extmem_size) {                  if (adr < extmem_size) {
                         cpumem[adr] = value;                          cpumem[adr] = value;
                 } else {  
                         ia32_panic("cpu_memorywrite: out of universe.");  
                 }                  }
         }          }
 }  }
Line 576  cpu_memorywrite(DWORD address, BYTE valu Line 554  cpu_memorywrite(DWORD address, BYTE valu
 DWORD MEMCALL  DWORD MEMCALL
 cpu_memoryread_d(DWORD address)  cpu_memoryread_d(DWORD address)
 {  {
         DWORD adr = address & cpumem_addrmask;          DWORD adr = address & CPU_STAT_ADRSMASK;
         DWORD val;          DWORD val;
   
         if (adr < LOWMEM - 3) {          if (adr < LOWMEM - 3) {
Line 586  cpu_memoryread_d(DWORD address) Line 564  cpu_memoryread_d(DWORD address)
                 val |= (DWORD)cpu_memoryread_w(adr + 2) << 16;                  val |= (DWORD)cpu_memoryread_w(adr + 2) << 16;
         } else {          } else {
                 adr -= LOWMEM;                  adr -= LOWMEM;
                 if (adr < extmem_size) {                  if (adr < extmem_size - 3) {
                         val = GETDWORD(cpumem + adr);                          val = LOADINTELDWORD(cpumem + adr);
                 } else {                  } else {
                         val = (DWORD)-1;                          val = cpu_memoryread_w(adr);
                         ia32_panic("cpu_memoryread_d: out of universe.");                          val |= (DWORD)cpu_memoryread_w(adr + 2) << 16;
                 }                  }
         }          }
         return val;          return val;
Line 599  cpu_memoryread_d(DWORD address) Line 577  cpu_memoryread_d(DWORD address)
 WORD MEMCALL  WORD MEMCALL
 cpu_memoryread_w(DWORD address)  cpu_memoryread_w(DWORD address)
 {  {
         DWORD adr = address & cpumem_addrmask;          DWORD adr = address & CPU_STAT_ADRSMASK;
         WORD val;          WORD val;
   
         if (adr < LOWMEM - 1) {          if (adr < LOWMEM - 1) {
Line 609  cpu_memoryread_w(DWORD address) Line 587  cpu_memoryread_w(DWORD address)
                 val |= (WORD)cpumem[adr - (LOWMEM - 1)] << 8;                  val |= (WORD)cpumem[adr - (LOWMEM - 1)] << 8;
         } else {          } else {
                 adr -= LOWMEM;                  adr -= LOWMEM;
                 if (adr < extmem_size) {                  if (adr < extmem_size - 1) {
                         val = GETWORD(cpumem + adr);                          val = LOADINTELWORD(cpumem + adr);
                   } else if (adr == extmem_size - 1) {
                           val = 0xff00 | cpumem[adr];
                 } else {                  } else {
                         val = (WORD)-1;                          val = (WORD)-1;
                         ia32_panic("cpu_memoryread_w: out of universe.");  
                 }                  }
         }          }
         return val;          return val;
Line 622  cpu_memoryread_w(DWORD address) Line 601  cpu_memoryread_w(DWORD address)
 BYTE MEMCALL  BYTE MEMCALL
 cpu_memoryread(DWORD address)  cpu_memoryread(DWORD address)
 {  {
         DWORD adr = address & cpumem_addrmask;          DWORD adr = address & CPU_STAT_ADRSMASK;
         BYTE val;          BYTE val;
   
         if (adr < LOWMEM) {          if (adr < LOWMEM) {
Line 633  cpu_memoryread(DWORD address) Line 612  cpu_memoryread(DWORD address)
                         val = cpumem[adr];                          val = cpumem[adr];
                 } else {                  } else {
                         val = (BYTE)-1;                          val = (BYTE)-1;
                         ia32_panic("cpu_memoryread: out of universe.");  
                 }                  }
         }          }
         return val;          return val;
Removed from v.1.1  
changed lines
  Added in v.1.5

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