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

Diff for /np2/i386c/memory.c between versions 1.38 and 1.39

version 1.38, 2012/01/23 10:50:55 version 1.39, 2012/01/24 17:28:22
Line 582  void MEMCALL memp_writes(UINT32 address, Line 582  void MEMCALL memp_writes(UINT32 address,
   
 // ---- Logical Space (BIOS)  // ---- Logical Space (BIOS)
   
   #if !defined(DEBUG)
 void MEMCALL meml_reads(UINT32 address, void *dat, UINT leng) {  void MEMCALL meml_reads(UINT32 address, void *dat, UINT leng) {
   #else
   void MEMCALL meml_reads(UINT32 address, void *dat, UINT leng, const char *fname, int line) {
   #endif
   
         if (!CPU_STAT_PM) {          if (!CPU_STAT_PM) {
                 memp_reads(address, dat, leng);                  memp_reads(address, dat, leng);
         }          }
         else if (CPU_STAT_VM86) {          else if (CPU_STAT_VM86) {
   #if defined(DEBUG)
                   int rv = sigsetjmp(exec_1step_jmpbuf, 1);
                   switch (rv) {
                   case 0:
                           break;
                   case 1:
                           ia32_panic("meml_reads: call from BIOS(%s:%d), PF_EXCEPTION",
                               fname, line);
                           return;
                   default:
                           ia32_panic("meml_reads: call from BIOS(%s:%d), unknown",
                               fname, line);
                           return;
                   }
   #endif
                 cpu_memory_access_la_region(address, leng,                  cpu_memory_access_la_region(address, leng,
                   CPU_PAGE_READ_DATA | CPU_PAGE_USER_MODE, dat);                    CPU_PAGE_READ_DATA | CPU_PAGE_USER_MODE, dat);
         }          }
Line 596  void MEMCALL meml_reads(UINT32 address,  Line 615  void MEMCALL meml_reads(UINT32 address, 
         }          }
 }  }
   
   #if !defined(DEBUG)
 void MEMCALL meml_writes(UINT32 address, const void *dat, UINT leng) {  void MEMCALL meml_writes(UINT32 address, const void *dat, UINT leng) {
   #else
   void MEMCALL meml_writes(UINT32 address, const void *dat, UINT leng, const char *fname, int line) {
   #endif
   
         if (!CPU_STAT_PM) {          if (!CPU_STAT_PM) {
                 memp_writes(address, dat, leng);                  memp_writes(address, dat, leng);
         }          }
         else if (CPU_STAT_VM86) {          else if (CPU_STAT_VM86) {
   #if defined(DEBUG)
                   int rv = sigsetjmp(exec_1step_jmpbuf, 1);
                   switch (rv) {
                   case 0:
                           break;
                   case 1:
                           ia32_panic("meml_writes: call from BIOS(%s:%d), PF_EXCEPTION",
                               fname, line);
                           return;
                   default:
                           ia32_panic("meml_writes: call from BIOS(%s:%d), unknown",
                               fname, line);
                           return;
                   }
   #endif
                 cpu_memory_access_la_region(address, leng,                  cpu_memory_access_la_region(address, leng,
                   CPU_PAGE_WRITE_DATA | CPU_PAGE_USER_MODE, (UINT8 *)dat);                    CPU_PAGE_WRITE_DATA | CPU_PAGE_USER_MODE, (UINT8 *)dat);
         }          }
Line 611  void MEMCALL meml_writes(UINT32 address, Line 649  void MEMCALL meml_writes(UINT32 address,
 }  }
   
   
   #if !defined(DEBUG)
 REG8 MEMCALL memr_read8(UINT seg, UINT off) {  REG8 MEMCALL memr_read8(UINT seg, UINT off) {
   #else
   REG8 MEMCALL memr_read8(UINT seg, UINT off, const char *fname, int line) {
   #endif
   
         UINT32  addr;          UINT32  addr;
   
Line 620  REG8 MEMCALL memr_read8(UINT seg, UINT o Line 662  REG8 MEMCALL memr_read8(UINT seg, UINT o
                 return(memp_read8(addr));                  return(memp_read8(addr));
         }          }
         else if (CPU_STAT_VM86) {          else if (CPU_STAT_VM86) {
   #if defined(DEBUG)
                   int rv = sigsetjmp(exec_1step_jmpbuf, 1);
                   switch (rv) {
                   case 0:
                           break;
                   case 1:
                           ia32_panic("memr_read8: call from BIOS(%s:%d), PF_EXCEPTION",
                               fname, line);
                           return(0xff);
                   default:
                           ia32_panic("memr_read8: call from BIOS(%s:%d), unknown",
                               fname, line);
                           return(0xff);
                   }
   #endif
                 return(cpu_linear_memory_read_b(addr,                  return(cpu_linear_memory_read_b(addr,
                   CPU_PAGE_READ_DATA | CPU_PAGE_USER_MODE));                    CPU_PAGE_READ_DATA | CPU_PAGE_USER_MODE));
         }          }
Line 629  REG8 MEMCALL memr_read8(UINT seg, UINT o Line 686  REG8 MEMCALL memr_read8(UINT seg, UINT o
         }          }
 }  }
   
   #if !defined(DEBUG)
 REG16 MEMCALL memr_read16(UINT seg, UINT off) {  REG16 MEMCALL memr_read16(UINT seg, UINT off) {
   #else
   REG16 MEMCALL memr_read16(UINT seg, UINT off, const char *fname, int line) {
   #endif
   
         UINT32  addr;          UINT32  addr;
   
Line 638  REG16 MEMCALL memr_read16(UINT seg, UINT Line 699  REG16 MEMCALL memr_read16(UINT seg, UINT
                 return(memp_read16(addr));                  return(memp_read16(addr));
         }          }
         else if (CPU_STAT_VM86) {          else if (CPU_STAT_VM86) {
   #if defined(DEBUG)
                   int rv = sigsetjmp(exec_1step_jmpbuf, 1);
                   switch (rv) {
                   case 0:
                           break;
                   case 1:
                           ia32_panic("memr_read16: call from BIOS(%s:%d), PF_EXCEPTION",
                               fname, line);
                           return(0xffff);
                   default:
                           ia32_panic("memr_read16: call from BIOS(%s:%d), unknown",
                               fname, line);
                           return(0xffff);
                   }
   #endif
                 return(cpu_linear_memory_read_w(addr,                  return(cpu_linear_memory_read_w(addr,
                   CPU_PAGE_READ_DATA | CPU_PAGE_USER_MODE));                    CPU_PAGE_READ_DATA | CPU_PAGE_USER_MODE));
         }          }
Line 647  REG16 MEMCALL memr_read16(UINT seg, UINT Line 723  REG16 MEMCALL memr_read16(UINT seg, UINT
         }          }
 }  }
   
   #if !defined(DEBUG)
 void MEMCALL memr_write8(UINT seg, UINT off, REG8 dat) {  void MEMCALL memr_write8(UINT seg, UINT off, REG8 dat) {
   #else
   void MEMCALL memr_write8(UINT seg, UINT off, REG8 dat, const char *fname, int line) {
   #endif
   
         UINT32  addr;          UINT32  addr;
   
Line 656  void MEMCALL memr_write8(UINT seg, UINT  Line 736  void MEMCALL memr_write8(UINT seg, UINT 
                 memp_write8(addr, dat);                  memp_write8(addr, dat);
         }          }
         else if (CPU_STAT_VM86) {          else if (CPU_STAT_VM86) {
   #if defined(DEBUG)
                   int rv = sigsetjmp(exec_1step_jmpbuf, 1);
                   switch (rv) {
                   case 0:
                           break;
                   case 1:
                           ia32_panic("memr_write8: call from BIOS(%s:%d), PF_EXCEPTION",
                               fname, line);
                           return;
                   default:
                           ia32_panic("memr_write8: call from BIOS(%s:%d), unknown",
                               fname, line);
                           return;
                   }
   #endif
                 cpu_linear_memory_write_b(addr, dat,                  cpu_linear_memory_write_b(addr, dat,
                   CPU_PAGE_WRITE_DATA | CPU_PAGE_USER_MODE);                    CPU_PAGE_WRITE_DATA | CPU_PAGE_USER_MODE);
         }          }
Line 664  void MEMCALL memr_write8(UINT seg, UINT  Line 759  void MEMCALL memr_write8(UINT seg, UINT 
         }          }
 }  }
   
   #if !defined(DEBUG)
 void MEMCALL memr_write16(UINT seg, UINT off, REG16 dat) {  void MEMCALL memr_write16(UINT seg, UINT off, REG16 dat) {
   #else
   void MEMCALL memr_write16(UINT seg, UINT off, REG16 dat, const char *fname, int line) {
   #endif
   
         UINT32  addr;          UINT32  addr;
   
Line 673  void MEMCALL memr_write16(UINT seg, UINT Line 772  void MEMCALL memr_write16(UINT seg, UINT
                 memp_write16(addr, dat);                  memp_write16(addr, dat);
         }          }
         else if (CPU_STAT_VM86) {          else if (CPU_STAT_VM86) {
   #if defined(DEBUG)
                   int rv = sigsetjmp(exec_1step_jmpbuf, 1);
                   switch (rv) {
                   case 0:
                           break;
                   case 1:
                           ia32_panic("memr_write16: call from BIOS(%s:%d), PF_EXCEPTION",
                               fname, line);
                           return;
                   default:
                           ia32_panic("memr_write16: call from BIOS(%s:%d), unknown",
                               fname, line);
                           return;
                   }
   #endif
                 cpu_linear_memory_write_w(addr, dat,                  cpu_linear_memory_write_w(addr, dat,
                   CPU_PAGE_WRITE_DATA | CPU_PAGE_USER_MODE);                    CPU_PAGE_WRITE_DATA | CPU_PAGE_USER_MODE);
         }          }
Line 681  void MEMCALL memr_write16(UINT seg, UINT Line 795  void MEMCALL memr_write16(UINT seg, UINT
         }          }
 }  }
   
   #if !defined(DEBUG)
 void MEMCALL memr_reads(UINT seg, UINT off, void *dat, UINT leng) {  void MEMCALL memr_reads(UINT seg, UINT off, void *dat, UINT leng) {
   #else
   void MEMCALL memr_reads(UINT seg, UINT ooff, void *dat, UINT oleng, const char *fname, int line) {
   #endif
   
         UINT8   *in = dat;          UINT8   *in = dat;
         UINT32  addr;          UINT32  addr;
         UINT    rem;          UINT    rem;
         UINT    size;          UINT    size;
   #if defined(DEBUG)
           UINT    off = ooff, leng = oleng;
   #endif
   
         if (CPU_STAT_PM && !CPU_STAT_VM86) {          if (CPU_STAT_PM && !CPU_STAT_VM86) {
                 ia32_panic("memr_reads: call from BIOS, but protected mode");                  ia32_panic("memr_reads: call from BIOS, but protected mode");
                 return;                  return;
         }          }
   #if defined(DEBUG)
           else if (CPU_STAT_PM && CPU_STAT_VM86) {
                   int rv = sigsetjmp(exec_1step_jmpbuf, 1);
                   switch (rv) {
                   case 0:
                           break;
                   case 1:
                           ia32_panic("memr_reads: call from BIOS(%s:%d), PF_EXCEPTION",
                               fname, line);
                           return;
                   default:
                           ia32_panic("memr_reads: call from BIOS(%s:%d), unknown",
                               fname, line);
                           return;
                   }
           }
   #endif
   
         while(leng) {          while(leng) {
                 off = LOW16(off);                  off = LOW16(off);
Line 714  void MEMCALL memr_reads(UINT seg, UINT o Line 852  void MEMCALL memr_reads(UINT seg, UINT o
         }          }
 }  }
   
   #if !defined(DEBUG)
 void MEMCALL memr_writes(UINT seg, UINT off, const void *dat, UINT leng) {  void MEMCALL memr_writes(UINT seg, UINT off, const void *dat, UINT leng) {
   #else
   void MEMCALL memr_writes(UINT seg, UINT ooff, const void *dat, UINT oleng, const char *fname, int line) {
   #endif
   
         const UINT8     *out = dat;          const UINT8     *out = dat;
         UINT32          addr;          UINT32          addr;
         UINT            rem;          UINT            rem;
         UINT            size;          UINT            size;
   #if defined(DEBUG)
           UINT            off = ooff, leng = oleng;
   #endif
   
         if (CPU_STAT_PM && !CPU_STAT_VM86) {          if (CPU_STAT_PM && !CPU_STAT_VM86) {
                 ia32_panic("memr_writes: call from BIOS, but protected mode");                  ia32_panic("memr_writes: call from BIOS, but protected mode");
                 return;                  return;
         }          }
   #if defined(DEBUG)
           else if (CPU_STAT_PM && CPU_STAT_VM86) {
                   int rv = sigsetjmp(exec_1step_jmpbuf, 1);
                   switch (rv) {
                   case 0:
                           break;
                   case 1:
                           ia32_panic("memr_writes: call from BIOS(%s:%d), PF_EXCEPTION",
                               fname, line);
                           return;
                   default:
                           ia32_panic("memr_writes: call from BIOS(%s:%d), unknown",
                               fname, line);
                           return;
                   }
           }
   #endif
   
         while(leng) {          while(leng) {
                 off = LOW16(off);                  off = LOW16(off);
Removed from v.1.38  
changed lines
  Added in v.1.39

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