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

Diff for /np2/i386c/ia32/paging.c between versions 1.38 and 1.40

version 1.38, 2012/01/23 06:01:44 version 1.40, 2012/01/29 14:53:26
Line 204  UINT8 MEMCALL Line 204  UINT8 MEMCALL
 cpu_memory_access_la_RMW_b(UINT32 laddr, UINT32 (CPUCALL *func)(UINT32, void *), void *arg)  cpu_memory_access_la_RMW_b(UINT32 laddr, UINT32 (CPUCALL *func)(UINT32, void *), void *arg)
 {  {
         const int ucrw = CPU_PAGE_WRITE_DATA | CPU_STAT_USER_MODE;          const int ucrw = CPU_PAGE_WRITE_DATA | CPU_STAT_USER_MODE;
         struct tlb_entry *ep;  
         UINT32 paddr;          UINT32 paddr;
         UINT32 result;          UINT32 result;
         UINT8 value;          UINT8 value;
   
         /* TLB */  
         ep = tlb_lookup(laddr, ucrw);  
         if (ep != NULL) {  
                 paddr = ep->paddr + (laddr & CPU_PAGE_MASK);  
                 goto onepage;  
         }  
   
         /* paging */  
         paddr = paging(laddr, ucrw);          paddr = paging(laddr, ucrw);
 onepage:  
         value = cpu_memoryread(paddr);          value = cpu_memoryread(paddr);
         result = (*func)(value, arg);          result = (*func)(value, arg);
         cpu_memorywrite(paddr, (UINT8)result);          cpu_memorywrite(paddr, (UINT8)result);
Line 229  UINT16 MEMCALL Line 219  UINT16 MEMCALL
 cpu_memory_access_la_RMW_w(UINT32 laddr, UINT32 (CPUCALL *func)(UINT32, void *), void *arg)  cpu_memory_access_la_RMW_w(UINT32 laddr, UINT32 (CPUCALL *func)(UINT32, void *), void *arg)
 {  {
         const int ucrw = CPU_PAGE_WRITE_DATA | CPU_STAT_USER_MODE;          const int ucrw = CPU_PAGE_WRITE_DATA | CPU_STAT_USER_MODE;
         struct tlb_entry *ep[2];  
         UINT32 paddr[2];          UINT32 paddr[2];
         UINT32 result;          UINT32 result;
         UINT16 value;          UINT16 value;
   
         /* TLB */  
         ep[0] = tlb_lookup(laddr, ucrw);  
         if (ep[0] != NULL) {  
                 paddr[0] = ep[0]->paddr + (laddr & CPU_PAGE_MASK);  
                 if ((laddr + 1) & CPU_PAGE_MASK)  
                         goto onepage;  
   
                 ep[1] = tlb_lookup(laddr + 1, ucrw);  
                 if (ep[1] != NULL) {  
                         paddr[1] = ep[1]->paddr + (laddr & CPU_PAGE_MASK);  
                         goto separate;  
                 }  
         }  
   
         /* paging */  
         paddr[0] = paging(laddr, ucrw);          paddr[0] = paging(laddr, ucrw);
         if ((laddr + 1) & CPU_PAGE_MASK) {          if ((laddr + 1) & CPU_PAGE_MASK) {
 onepage:  
                 value = cpu_memoryread_w(paddr[0]);                  value = cpu_memoryread_w(paddr[0]);
                 result = (*func)(value, arg);                  result = (*func)(value, arg);
                 cpu_memorywrite_w(paddr[0], (UINT16)result);                  cpu_memorywrite_w(paddr[0], (UINT16)result);
Line 259  onepage: Line 232  onepage:
         }          }
   
         paddr[1] = paging(laddr + 1, ucrw);          paddr[1] = paging(laddr + 1, ucrw);
 separate:  
         value = cpu_memoryread_b(paddr[0]);          value = cpu_memoryread_b(paddr[0]);
         value += (UINT16)cpu_memoryread_b(paddr[1]) << 8;          value += (UINT16)cpu_memoryread_b(paddr[1]) << 8;
         result = (*func)(value, arg);          result = (*func)(value, arg);
Line 272  UINT32 MEMCALL Line 244  UINT32 MEMCALL
 cpu_memory_access_la_RMW_d(UINT32 laddr, UINT32 (CPUCALL *func)(UINT32, void *), void *arg)  cpu_memory_access_la_RMW_d(UINT32 laddr, UINT32 (CPUCALL *func)(UINT32, void *), void *arg)
 {  {
         const int ucrw = CPU_PAGE_WRITE_DATA | CPU_STAT_USER_MODE;          const int ucrw = CPU_PAGE_WRITE_DATA | CPU_STAT_USER_MODE;
         struct tlb_entry *ep[2];  
         UINT32 paddr[2];          UINT32 paddr[2];
         UINT32 result;          UINT32 result;
         UINT32 value;          UINT32 value;
         int remain;          int remain;
   
         /* TLB */  
         ep[0] = tlb_lookup(laddr, ucrw);  
         if (ep[0] != NULL) {  
                 paddr[0] = ep[0]->paddr + (laddr & CPU_PAGE_MASK);  
                 remain = CPU_PAGE_SIZE - (laddr & CPU_PAGE_MASK);  
                 if (remain >= 4)  
                         goto onepage;  
   
                 ep[1] = tlb_lookup(laddr + remain, ucrw);  
                 if (ep[1] != NULL) {  
                         paddr[1] = ep[1]->paddr + (laddr & CPU_PAGE_MASK);  
                         goto separate;  
                 }  
         }  
   
         /* paging */  
         paddr[0] = paging(laddr, ucrw);          paddr[0] = paging(laddr, ucrw);
         remain = CPU_PAGE_SIZE - (laddr & CPU_PAGE_MASK);          remain = CPU_PAGE_SIZE - (laddr & CPU_PAGE_MASK);
         if (remain >= 4) {          if (remain >= 4) {
 onepage:  
                 value = cpu_memoryread_d(paddr[0]);                  value = cpu_memoryread_d(paddr[0]);
                 result = (*func)(value, arg);                  result = (*func)(value, arg);
                 cpu_memorywrite_d(paddr[0], result);                  cpu_memorywrite_d(paddr[0], result);
Line 305  onepage: Line 259  onepage:
         }          }
   
         paddr[1] = paging(laddr + remain, ucrw);          paddr[1] = paging(laddr + remain, ucrw);
 separate:  
         switch (remain) {          switch (remain) {
         case 3:          case 3:
                 value = cpu_memoryread(paddr[0]);                  value = cpu_memoryread(paddr[0]);
Line 347  separate: Line 300  separate:
 UINT8 MEMCALL  UINT8 MEMCALL
 cpu_linear_memory_read_b(UINT32 laddr, int ucrw)  cpu_linear_memory_read_b(UINT32 laddr, int ucrw)
 {  {
         struct tlb_entry *ep;  
         UINT32 paddr;  
   
         /* TLB */  
         ep = tlb_lookup(laddr, ucrw);  
         if (ep != NULL) {  
                 paddr = ep->paddr + (laddr & CPU_PAGE_MASK);  
                 return cpu_memoryread(paddr);  
         }  
   
         /* paging */          return cpu_memoryread(paging(laddr, ucrw));
         paddr = paging(laddr, ucrw);  
         return cpu_memoryread(paddr);  
 }  }
   
 UINT16 MEMCALL  UINT16 MEMCALL
 cpu_linear_memory_read_w(UINT32 laddr, int ucrw)  cpu_linear_memory_read_w(UINT32 laddr, int ucrw)
 {  {
         struct tlb_entry *ep[2];  
         UINT32 paddr[2];          UINT32 paddr[2];
         UINT16 value;          UINT16 value;
   
         /* TLB */  
         ep[0] = tlb_lookup(laddr, ucrw);  
         if (ep[0] != NULL) {  
                 paddr[0] = ep[0]->paddr + (laddr & CPU_PAGE_MASK);  
                 if ((laddr + 1) & CPU_PAGE_MASK)  
                         return cpu_memoryread_w(paddr[0]);  
   
                 ep[1] = tlb_lookup(laddr + 1, ucrw);  
                 if (ep[1] != NULL) {  
                         paddr[1] = ep[1]->paddr;  
                         goto separate;  
                 }  
         }  
   
         /* paging */  
         paddr[0] = paging(laddr, ucrw);          paddr[0] = paging(laddr, ucrw);
         if ((laddr + 1) & CPU_PAGE_MASK)          if ((laddr + 1) & CPU_PAGE_MASK)
                 return cpu_memoryread_w(paddr[0]);                  return cpu_memoryread_w(paddr[0]);
   
         paddr[1] = paging(laddr + 1, ucrw);          paddr[1] = paging(laddr + 1, ucrw);
 separate:  
         value = cpu_memoryread_b(paddr[0]);          value = cpu_memoryread_b(paddr[0]);
         value += (UINT16)cpu_memoryread_b(paddr[1]) << 8;          value += (UINT16)cpu_memoryread_b(paddr[1]) << 8;
         return value;          return value;
Line 398  separate: Line 323  separate:
 UINT32 MEMCALL  UINT32 MEMCALL
 cpu_linear_memory_read_d(UINT32 laddr, int ucrw)  cpu_linear_memory_read_d(UINT32 laddr, int ucrw)
 {  {
         struct tlb_entry *ep[2];  
         UINT32 paddr[2];          UINT32 paddr[2];
         UINT32 value;          UINT32 value;
         UINT remain;          UINT remain;
   
         /* TLB */  
         ep[0] = tlb_lookup(laddr, ucrw);  
         if (ep[0] != NULL) {  
                 paddr[0] = ep[0]->paddr + (laddr & CPU_PAGE_MASK);  
                 remain = CPU_PAGE_SIZE - (laddr & CPU_PAGE_MASK);  
                 if (remain >= sizeof(value))  
                         return cpu_memoryread_d(paddr[0]);  
   
                 ep[1] = tlb_lookup(laddr + remain, ucrw);  
                 if (ep[1] != NULL) {  
                         paddr[1] = ep[1]->paddr;  
                         goto separate;  
                 }  
         }  
   
         /* paging */  
         paddr[0] = paging(laddr, ucrw);          paddr[0] = paging(laddr, ucrw);
         remain = CPU_PAGE_SIZE - (laddr & CPU_PAGE_MASK);          remain = CPU_PAGE_SIZE - (laddr & CPU_PAGE_MASK);
         if (remain >= sizeof(value))          if (remain >= sizeof(value))
                 return cpu_memoryread_d(paddr[0]);                  return cpu_memoryread_d(paddr[0]);
   
         paddr[1] = paging(laddr + remain, ucrw);          paddr[1] = paging(laddr + remain, ucrw);
 separate:  
         switch (remain) {          switch (remain) {
         case 3:          case 3:
                 value = cpu_memoryread(paddr[0]);                  value = cpu_memoryread(paddr[0]);
Line 455  separate: Line 362  separate:
 UINT64 MEMCALL  UINT64 MEMCALL
 cpu_linear_memory_read_q(UINT32 laddr, int ucrw)  cpu_linear_memory_read_q(UINT32 laddr, int ucrw)
 {  {
         struct tlb_entry *ep[2];  
         UINT32 paddr[2];          UINT32 paddr[2];
         UINT64 value;          UINT64 value;
         UINT remain;          UINT remain;
   
         /* TLB */  
         ep[0] = tlb_lookup(laddr, ucrw);  
         if (ep[0] != NULL) {  
                 paddr[0] = ep[0]->paddr + (laddr & CPU_PAGE_MASK);  
                 remain = CPU_PAGE_SIZE - (laddr & CPU_PAGE_MASK);  
                 if (remain >= sizeof(value))  
                         return cpu_memoryread_d(paddr[0]);  
   
                 ep[1] = tlb_lookup(laddr + remain, ucrw);  
                 if (ep[1] != NULL) {  
                         paddr[1] = ep[1]->paddr;  
                         goto separate;  
                 }  
         }  
   
         /* paging */  
         paddr[0] = paging(laddr, ucrw);          paddr[0] = paging(laddr, ucrw);
         remain = CPU_PAGE_SIZE - (laddr & CPU_PAGE_MASK);          remain = CPU_PAGE_SIZE - (laddr & CPU_PAGE_MASK);
         if (remain >= sizeof(value))          if (remain >= sizeof(value))
                 return cpu_memoryread_q(paddr[0]);                  return cpu_memoryread_q(paddr[0]);
   
         paddr[1] = paging(laddr + remain, ucrw);          paddr[1] = paging(laddr + remain, ucrw);
 separate:  
         switch (remain) {          switch (remain) {
         case 7:          case 7:
                 value = cpu_memoryread(paddr[0]);                  value = cpu_memoryread(paddr[0]);
Line 540  separate: Line 429  separate:
 REG80 MEMCALL  REG80 MEMCALL
 cpu_linear_memory_read_f(UINT32 laddr, int ucrw)  cpu_linear_memory_read_f(UINT32 laddr, int ucrw)
 {  {
         struct tlb_entry *ep[2];  
         UINT32 paddr[2];          UINT32 paddr[2];
         REG80 value;          REG80 value;
         UINT remain;          UINT remain;
         UINT i, j;          UINT i, j;
   
         /* TLB */  
         ep[0] = tlb_lookup(laddr, ucrw);  
         if (ep[0] != NULL) {  
                 paddr[0] = ep[0]->paddr + (laddr & CPU_PAGE_MASK);  
                 remain = CPU_PAGE_SIZE - (laddr & CPU_PAGE_MASK);  
                 if (remain >= sizeof(value))  
                         return cpu_memoryread_f(paddr[0]);  
   
                 ep[1] = tlb_lookup(laddr + remain, ucrw);  
                 if (ep[1] != NULL) {  
                         paddr[1] = ep[1]->paddr;  
                         goto separate;  
                 }  
         }  
   
         /* paging */  
         paddr[0] = paging(laddr, ucrw);          paddr[0] = paging(laddr, ucrw);
         remain = CPU_PAGE_SIZE - (laddr & CPU_PAGE_MASK);          remain = CPU_PAGE_SIZE - (laddr & CPU_PAGE_MASK);
         if (remain >= sizeof(value))          if (remain >= sizeof(value))
                 return cpu_memoryread_f(paddr[0]);                  return cpu_memoryread_f(paddr[0]);
   
         paddr[1] = paging(laddr + remain, ucrw);          paddr[1] = paging(laddr + remain, ucrw);
 separate:  
         for (i = 0; i < remain; ++i) {          for (i = 0; i < remain; ++i) {
                 value.b[i] = cpu_memoryread(paddr[0] + i);                  value.b[i] = cpu_memoryread(paddr[0] + i);
         }          }
Line 582  separate: Line 453  separate:
 void MEMCALL  void MEMCALL
 cpu_linear_memory_write_b(UINT32 laddr, UINT8 value, int ucrw)  cpu_linear_memory_write_b(UINT32 laddr, UINT8 value, int ucrw)
 {  {
         struct tlb_entry *ep;  
         UINT32 paddr;  
   
         /* TLB */  
         ep = tlb_lookup(laddr, ucrw);  
         if (ep != NULL) {  
                 paddr = ep->paddr + (laddr & CPU_PAGE_MASK);  
                 cpu_memorywrite(paddr, value);  
                 return;  
         }  
   
         /* paging */          cpu_memorywrite(paging(laddr, ucrw), value);
         paddr = paging(laddr, ucrw);  
         cpu_memorywrite(paddr, value);  
 }  }
   
 void MEMCALL  void MEMCALL
 cpu_linear_memory_write_w(UINT32 laddr, UINT16 value, int ucrw)  cpu_linear_memory_write_w(UINT32 laddr, UINT16 value, int ucrw)
 {  {
         struct tlb_entry *ep[2];  
         UINT32 paddr[2];          UINT32 paddr[2];
   
         /* TLB */  
         ep[0] = tlb_lookup(laddr, ucrw);  
         if (ep[0] != NULL) {  
                 paddr[0] = ep[0]->paddr + (laddr & CPU_PAGE_MASK);  
                 if ((laddr + 1) & CPU_PAGE_MASK) {  
                         cpu_memorywrite_w(paddr[0], value);  
                         return;  
                 }  
   
                 ep[1] = tlb_lookup(laddr + 1, ucrw);  
                 if (ep[1] != NULL) {  
                         paddr[1] = ep[1]->paddr;  
                         goto separate;  
                 }  
         }  
   
         /* paging */  
         paddr[0] = paging(laddr, ucrw);          paddr[0] = paging(laddr, ucrw);
         if ((laddr + 1) & CPU_PAGE_MASK) {          if ((laddr + 1) & CPU_PAGE_MASK) {
                 cpu_memorywrite_w(paddr[0], value);                  cpu_memorywrite_w(paddr[0], value);
Line 628  cpu_linear_memory_write_w(UINT32 laddr,  Line 469  cpu_linear_memory_write_w(UINT32 laddr, 
         }          }
   
         paddr[1] = paging(laddr + 1, ucrw);          paddr[1] = paging(laddr + 1, ucrw);
 separate:  
         cpu_memorywrite(paddr[0], (UINT8)value);          cpu_memorywrite(paddr[0], (UINT8)value);
         cpu_memorywrite(paddr[1], (UINT8)(value >> 8));          cpu_memorywrite(paddr[1], (UINT8)(value >> 8));
 }  }
Line 636  separate: Line 476  separate:
 void MEMCALL  void MEMCALL
 cpu_linear_memory_write_d(UINT32 laddr, UINT32 value, int ucrw)  cpu_linear_memory_write_d(UINT32 laddr, UINT32 value, int ucrw)
 {  {
         struct tlb_entry *ep[2];  
         UINT32 paddr[2];          UINT32 paddr[2];
         UINT remain;          UINT remain;
   
         /* TLB */  
         ep[0] = tlb_lookup(laddr, ucrw);  
         if (ep[0] != NULL) {  
                 paddr[0] = ep[0]->paddr + (laddr & CPU_PAGE_MASK);  
                 remain = CPU_PAGE_SIZE - (laddr & CPU_PAGE_MASK);  
                 if (remain >= sizeof(value)) {  
                         cpu_memorywrite_d(paddr[0], value);  
                         return;  
                 }  
   
                 ep[1] = tlb_lookup(laddr + remain, ucrw);  
                 if (ep[1] != NULL) {  
                         paddr[1] = ep[1]->paddr;  
                         goto separate;  
                 }  
         }  
   
         /* paging */  
         paddr[0] = paging(laddr, ucrw);          paddr[0] = paging(laddr, ucrw);
         remain = CPU_PAGE_SIZE - (laddr & CPU_PAGE_MASK);          remain = CPU_PAGE_SIZE - (laddr & CPU_PAGE_MASK);
         if (remain >= sizeof(value)) {          if (remain >= sizeof(value)) {
Line 666  cpu_linear_memory_write_d(UINT32 laddr,  Line 487  cpu_linear_memory_write_d(UINT32 laddr, 
         }          }
   
         paddr[1] = paging(laddr + remain, ucrw);          paddr[1] = paging(laddr + remain, ucrw);
 separate:  
         switch (remain) {          switch (remain) {
         case 3:          case 3:
                 cpu_memorywrite(paddr[0], (UINT8)value);                  cpu_memorywrite(paddr[0], (UINT8)value);
Line 694  separate: Line 514  separate:
 void MEMCALL  void MEMCALL
 cpu_linear_memory_write_q(UINT32 laddr, UINT64 value, int ucrw)  cpu_linear_memory_write_q(UINT32 laddr, UINT64 value, int ucrw)
 {  {
         struct tlb_entry *ep[2];  
         UINT32 paddr[2];          UINT32 paddr[2];
         UINT remain;          UINT remain;
   
         /* TLB */  
         ep[0] = tlb_lookup(laddr, ucrw);  
         if (ep[0] != NULL) {  
                 paddr[0] = ep[0]->paddr + (laddr & CPU_PAGE_MASK);  
                 remain = CPU_PAGE_SIZE - (laddr & CPU_PAGE_MASK);  
                 if (remain >= sizeof(value)) {  
                         cpu_memorywrite_q(paddr[0], value);  
                         return;  
                 }  
   
                 ep[1] = tlb_lookup(laddr + remain, ucrw);  
                 if (ep[1] != NULL) {  
                         paddr[1] = ep[1]->paddr;  
                         goto separate;  
                 }  
         }  
   
         /* paging */  
         paddr[0] = paging(laddr, ucrw);          paddr[0] = paging(laddr, ucrw);
         remain = CPU_PAGE_SIZE - (laddr & CPU_PAGE_MASK);          remain = CPU_PAGE_SIZE - (laddr & CPU_PAGE_MASK);
         if (remain >= sizeof(value)) {          if (remain >= sizeof(value)) {
Line 724  cpu_linear_memory_write_q(UINT32 laddr,  Line 525  cpu_linear_memory_write_q(UINT32 laddr, 
         }          }
   
         paddr[1] = paging(laddr + remain, ucrw);          paddr[1] = paging(laddr + remain, ucrw);
 separate:  
         switch (remain) {          switch (remain) {
         case 7:          case 7:
                 cpu_memorywrite(paddr[0], (UINT8)value);                  cpu_memorywrite(paddr[0], (UINT8)value);
Line 780  separate: Line 580  separate:
 void MEMCALL  void MEMCALL
 cpu_linear_memory_write_f(UINT32 laddr, const REG80 *value, int ucrw)  cpu_linear_memory_write_f(UINT32 laddr, const REG80 *value, int ucrw)
 {  {
         struct tlb_entry *ep[2];  
         UINT32 paddr[2];          UINT32 paddr[2];
         UINT remain;          UINT remain;
         UINT i, j;          UINT i, j;
   
         /* TLB */  
         ep[0] = tlb_lookup(laddr, ucrw);  
         if (ep[0] != NULL) {  
                 paddr[0] = ep[0]->paddr + (laddr & CPU_PAGE_MASK);  
                 remain = CPU_PAGE_SIZE - (laddr & CPU_PAGE_MASK);  
                 if (remain >= sizeof(value)) {  
                         cpu_memorywrite_f(paddr[0], value);  
                         return;  
                 }  
   
                 ep[1] = tlb_lookup(laddr + remain, ucrw);  
                 if (ep[1] != NULL) {  
                         paddr[1] = ep[1]->paddr;  
                         goto separate;  
                 }  
         }  
   
         /* paging */  
         paddr[0] = paging(laddr, ucrw);          paddr[0] = paging(laddr, ucrw);
         remain = CPU_PAGE_SIZE - (laddr & CPU_PAGE_MASK);          remain = CPU_PAGE_SIZE - (laddr & CPU_PAGE_MASK);
         if (remain >= sizeof(value)) {          if (remain >= sizeof(value)) {
Line 811  cpu_linear_memory_write_f(UINT32 laddr,  Line 592  cpu_linear_memory_write_f(UINT32 laddr, 
         }          }
   
         paddr[1] = paging(laddr + remain, ucrw);          paddr[1] = paging(laddr + remain, ucrw);
 separate:  
         for (i = 0; i < remain; ++i) {          for (i = 0; i < remain; ++i) {
                 cpu_memorywrite(paddr[0] + i, value->b[i]);                  cpu_memorywrite(paddr[0] + i, value->b[i]);
         }          }
Line 830  cpu_memory_access_la_region(UINT32 laddr Line 610  cpu_memory_access_la_region(UINT32 laddr
         UINT remain;    /* page remain */          UINT remain;    /* page remain */
         UINT r;          UINT r;
   
         if (length == 0)          while (length > 0) {
                 return;                  remain = CPU_PAGE_SIZE - (laddr & CPU_PAGE_MASK);
   
         remain = CPU_PAGE_SIZE - (laddr & CPU_PAGE_MASK);  
         for (;;) {  
                 if (!CPU_STAT_PAGING) {                  if (!CPU_STAT_PAGING) {
                         paddr = laddr;                          paddr = laddr;
                 } else {                  } else {
Line 848  cpu_memory_access_la_region(UINT32 laddr Line 625  cpu_memory_access_la_region(UINT32 laddr
                         cpu_memorywrite_region(paddr, data, r);                          cpu_memorywrite_region(paddr, data, r);
                 }                  }
   
                 length -= r;  
                 if (length == 0)  
                         break;  
   
                 data += r;  
                 laddr += r;                  laddr += r;
                 remain -= r;                  data += r;
                 if (remain <= 0) {                  length -= r;
                         /* next page */  
                         remain += CPU_PAGE_SIZE;  
                 }  
         }          }
 }  }
   
Line 875  laddr2paddr(UINT32 laddr, int ucrw) Line 644  laddr2paddr(UINT32 laddr, int ucrw)
 static UINT32 MEMCALL  static UINT32 MEMCALL
 paging(UINT32 laddr, int ucrw)  paging(UINT32 laddr, int ucrw)
 {  {
           struct tlb_entry *ep;
         UINT32 paddr;           /* physical address */          UINT32 paddr;           /* physical address */
         UINT32 pde_addr;        /* page directory entry address */          UINT32 pde_addr;        /* page directory entry address */
         UINT32 pde;             /* page directory entry */          UINT32 pde;             /* page directory entry */
Line 882  paging(UINT32 laddr, int ucrw) Line 652  paging(UINT32 laddr, int ucrw)
         UINT32 pte;             /* page table entry */          UINT32 pte;             /* page table entry */
         UINT bit;          UINT bit;
         UINT err;          UINT err;
         struct tlb_entry *ep;  
   
         ep = tlb_lookup(laddr, ucrw);          ep = tlb_lookup(laddr, ucrw);
         if (ep != NULL)          if (ep != NULL)
Removed from v.1.38  
changed lines
  Added in v.1.40

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