[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.7 and 1.12

version 1.7, 2004/01/27 15:56:57 version 1.12, 2004/02/20 16:09:04
Line 112 Line 112
  * +-----+-----------+-----+-----+---+   * +-----+-----------+-----+-----+---+
  */   */
 #if !defined(USE_PAGE_ACCESS_TABLE)  #if !defined(USE_PAGE_ACCESS_TABLE)
 static const DWORD page_access = 0xd0cdd0ff;  #define page_access     0xd0ddd0ff
 #else   /* USE_PAGE_ACCESS_TABLE */  #else   /* USE_PAGE_ACCESS_TABLE */
 static const BYTE page_access_bit[32] = {  static const UINT8 page_access_bit[32] = {
         1,      /* CR0: n, CPL: s, PTE: s, PTE: r, ope: r */          1,      /* CR0: n, CPL: s, PTE: s, PTE: r, ope: r */
         1,      /* CR0: n, CPL: s, PTE: s, PTE: r, ope: w */          1,      /* CR0: n, CPL: s, PTE: s, PTE: r, ope: w */
         1,      /* CR0: n, CPL: s, PTE: s, PTE: w, ope: r */          1,      /* CR0: n, CPL: s, PTE: s, PTE: w, ope: r */
Line 143  static const BYTE page_access_bit[32] =  Line 143  static const BYTE page_access_bit[32] = 
         1,      /* CR0: p, CPL: s, PTE: u, PTE: r, ope: r */          1,      /* CR0: p, CPL: s, PTE: u, PTE: r, ope: r */
         0,      /* CR0: p, CPL: s, PTE: u, PTE: r, ope: w */          0,      /* CR0: p, CPL: s, PTE: u, PTE: r, ope: w */
         1,      /* CR0: p, CPL: s, PTE: u, PTE: w, ope: r */          1,      /* CR0: p, CPL: s, PTE: u, PTE: w, ope: r */
         0,      /* CR0: p, CPL: s, PTE: u, PTE: w, ope: w */          1,      /* CR0: p, CPL: s, PTE: u, PTE: w, ope: w */
   
         0,      /* CR0: p, CPL: u, PTE: s, PTE: r, ope: r */          0,      /* CR0: p, CPL: u, PTE: s, PTE: r, ope: r */
         0,      /* CR0: p, CPL: u, PTE: s, PTE: r, ope: w */          0,      /* CR0: p, CPL: u, PTE: s, PTE: r, ope: w */
Line 184  static const BYTE page_access_bit[32] =  Line 184  static const BYTE page_access_bit[32] = 
  * +- CR3(物理アドレス)   * +- CR3(物理アドレス)
  */   */
   
 static DWORD paging(DWORD laddr, int crw, int user_mode);  static UINT32 paging(UINT32 laddr, int crw, int user_mode);
 #if defined(IA32_SUPPORT_TLB)  #if defined(IA32_SUPPORT_TLB)
 static BOOL tlb_lookup(DWORD vaddr, int crw, DWORD* paddr);  static BOOL tlb_lookup(UINT32 vaddr, int crw, UINT32 *paddr);
 static void tlb_update(DWORD paddr, DWORD entry, int crw);  static void tlb_update(UINT32 paddr, UINT entry, int crw);
 #endif  #endif
   
   
 DWORD MEMCALL  UINT32 MEMCALL
 cpu_linear_memory_read(DWORD laddr, DWORD length, int code)  cpu_linear_memory_read(UINT32 laddr, UINT length, int crw, int user_mode)
 {  {
         DWORD paddr;          UINT32 value = 0;
         DWORD remain;   /* page remain */          UINT32 paddr;
         DWORD r;          UINT remain;    /* page remain */
         DWORD shift = 0;          UINT r;
         DWORD value = 0;          int shift = 0;
         int crw;  
         int pl;  
   
         crw = CPU_PAGING_PAGE_READ;  
         crw |= code ? CPU_PAGING_PAGE_CODE : CPU_PAGING_PAGE_DATA;  
         pl = (CPU_STAT_CPL == 3);  
   
         /* XXX: 4MB pages... */          /* XXX: 4MB pages... */
         remain = 0x1000 - (laddr & 0x00000fff);          remain = 0x1000 - (laddr & 0x00000fff);
         for (;;) {          for (;;) {
                 paddr = paging(laddr, crw, pl);                  paddr = paging(laddr, crw, user_mode);
   
                 r = (remain > length) ? length : remain;                  r = (remain > length) ? length : remain;
                 switch (r) {                  switch (r) {
                 case 1:                  case 4:
                         value |= (DWORD)cpu_memoryread(paddr) << shift;                          value = cpu_memoryread_d(paddr);
                         shift += 8;  
                         break;                          break;
   
                   case 3:
                           value += (UINT32)cpu_memoryread(paddr) << shift;
                           shift += 8;
                           paddr++;
                           /*FALLTHROUGH*/
                 case 2:                  case 2:
                         value |= (DWORD)cpu_memoryread_w(paddr) << shift;                          value += (UINT32)cpu_memoryread_w(paddr) << shift;
                         shift += 16;                          shift += 16;
                         break;                          break;
   
                 case 3:                  case 1:
                         value |= (DWORD)cpu_memoryread_w(paddr) << shift;                          value += (UINT32)cpu_memoryread(paddr) << shift;
                         shift += 16;  
                         value |= (DWORD)cpu_memoryread(paddr + 2) << shift;  
                         shift += 8;                          shift += 8;
                         break;                          break;
   
                 case 4:  
                         value = cpu_memoryread_d(paddr);  
                         break;  
   
                 default:                  default:
                         ia32_panic("cpu_linear_memory_read(): out of range (r = %d)\n", r);                          ia32_panic("cpu_linear_memory_read(): out of range (r = %d)\n", r);
                         break;                          break;
Line 255  cpu_linear_memory_read(DWORD laddr, DWOR Line 247  cpu_linear_memory_read(DWORD laddr, DWOR
 }  }
   
 void MEMCALL  void MEMCALL
 cpu_linear_memory_write(DWORD laddr, DWORD length, DWORD value)  cpu_linear_memory_write(UINT32 laddr, UINT32 value, UINT length, int user_mode)
 {  {
         DWORD paddr;          UINT32 paddr;
         DWORD remain;   /* page remain */          UINT remain;    /* page remain */
         DWORD r;          UINT r;
         int crw;          int crw = (CPU_PAGE_WRITE|CPU_PAGE_DATA);
         int pl;  
   
         crw = CPU_PAGING_PAGE_WRITE;  
         crw |= CPU_PAGING_PAGE_DATA;  
         pl = (CPU_STAT_CPL == 3);  
   
         /* XXX: 4MB pages... */          /* XXX: 4MB pages... */
         remain = 0x1000 - (laddr & 0x00000fff);          remain = 0x1000 - (laddr & 0x00000fff);
         for (;;) {          for (;;) {
                 paddr = paging(laddr, crw, pl);                  paddr = paging(laddr, crw, user_mode);
   
                 r = (remain > length) ? length : remain;                  r = (remain > length) ? length : remain;
                 switch (r) {                  switch (r) {
                 case 1:                  case 4:
                         cpu_memorywrite(paddr, value & 0xff);                          cpu_memorywrite_d(paddr, value);
                         value >>= 8;  
                         break;                          break;
   
                   case 3:
                           cpu_memorywrite(paddr, value & 0xff);
                           value >>= 8;
                           paddr++;
                           /*FALLTHROUGH*/
                 case 2:                  case 2:
                         cpu_memorywrite_w(paddr, value & 0xffff);                          cpu_memorywrite_w(paddr, value & 0xffff);
                         value >>= 16;                          value >>= 16;
                         break;                          break;
   
                 case 3:                  case 1:
                         cpu_memorywrite_w(paddr, value & 0xffff);                          cpu_memorywrite(paddr, value & 0xff);
                         value >>= 16;  
                         cpu_memorywrite(paddr + 2, value & 0xff);  
                         value >>= 8;                          value >>= 8;
                         break;                          break;
   
                 case 4:  
                         cpu_memorywrite_d(paddr, value);  
                         break;  
   
                 default:                  default:
                         ia32_panic("cpu_linear_memory_write(): out of range (r = %d)\n", r);                          ia32_panic("cpu_linear_memory_write(): out of range (r = %d)\n", r);
                         break;                          break;
Line 314  cpu_linear_memory_write(DWORD laddr, DWO Line 299  cpu_linear_memory_write(DWORD laddr, DWO
 }  }
   
 void MEMCALL  void MEMCALL
 paging_check(DWORD laddr, DWORD length, int rw)  paging_check(UINT32 laddr, UINT length, int crw, int user_mode)
 {  {
         DWORD paddr;          UINT32 paddr;
         DWORD remain;   /* page remain */          UINT remain;    /* page remain */
         DWORD r;          UINT r;
         int crw;  
         int pl;  
   
         crw = rw;  
         pl = (CPU_STAT_CPL == 3);  
   
         /* XXX: 4MB pages... */          /* XXX: 4MB pages... */
         remain = 0x1000 - (laddr & 0x00000fff);          remain = 0x1000 - (laddr & 0x00000fff);
         for (;;) {          for (;;) {
                 paddr = paging(laddr, crw, pl);                  paddr = paging(laddr, crw, user_mode);
   
                 r = (remain > length) ? length : remain;                  r = (remain > length) ? length : remain;
   
Line 345  paging_check(DWORD laddr, DWORD length,  Line 325  paging_check(DWORD laddr, DWORD length, 
         }          }
 }  }
   
 static DWORD  static UINT32
 paging(DWORD laddr, int crw, int user_mode)  paging(UINT32 laddr, int crw, int user_mode)
 {  {
         DWORD paddr;    /* physical address */          UINT32 paddr;           /* physical address */
         DWORD pde_addr; /* page directory entry address */          UINT32 pde_addr;        /* page directory entry address */
         DWORD pde;      /* page directory entry */          UINT32 pde;             /* page directory entry */
         DWORD pte_addr; /* page table entry address */          UINT32 pte_addr;        /* page table entry address */
         DWORD pte;      /* page table entry */          UINT32 pte;             /* page table entry */
         DWORD bit;          UINT bit;
         DWORD err;          UINT err;
   
 #if defined(IA32_SUPPORT_TLB)  #if defined(IA32_SUPPORT_TLB)
         if (tlb_lookup(laddr, crw, &paddr))          if (tlb_lookup(laddr, crw, &paddr))
                 return paddr;                  return paddr;
 #endif  /* IA32_SUPPORT_TLB */  #endif  /* IA32_SUPPORT_TLB */
   
         pde_addr = (CPU_CR3 & CPU_CR3_PD_MASK) | ((laddr >> 20) & 0xffc);          pde_addr = CPU_STAT_PDE_BASE + ((laddr >> 20) & 0xffc);
         pde = cpu_memoryread_d(pde_addr);          pde = cpu_memoryread_d(pde_addr);
         if (!(pde & CPU_PDE_PRESENT)) {          if (!(pde & CPU_PDE_PRESENT)) {
                 VERBOSE(("paging: PDE is not present"));                  VERBOSE(("paging: PTE page is not present"));
                 VERBOSE(("paging: CPU_CR3 = 0x%08x", CPU_CR3));                  VERBOSE(("paging: CPU_CR3 = 0x%08x", CPU_CR3));
                 VERBOSE(("paging: laddr = 0x%08x, pde_addr = 0x%08x, pde = 0x%08x", laddr, pde_addr, pde));                  VERBOSE(("paging: laddr = 0x%08x, pde_addr = 0x%08x, pde = 0x%08x", laddr, pde_addr, pde));
                 err = 0;                  err = 0;
Line 375  paging(DWORD laddr, int crw, int user_mo Line 355  paging(DWORD laddr, int crw, int user_mo
                 cpu_memorywrite_d(pde_addr, pde);                  cpu_memorywrite_d(pde_addr, pde);
         }          }
   
   #if CPU_FAMILY >= 5
         /* no support PAE */          /* no support PAE */
         __ASSERT(!(CPU_CR4 & CPU_CR4_PAE));          __ASSERT(!(CPU_CR4 & CPU_CR4_PAE));
   
Line 386  paging(DWORD laddr, int crw, int user_mo Line 367  paging(DWORD laddr, int crw, int user_mo
                 pte_addr = 0;   /* compiler happy */                  pte_addr = 0;   /* compiler happy */
   
                 /* make physical address */                  /* make physical address */
                 paddr = (pde & CPU_PDE_4M_BASEADDR_MASK) | (laddr & 0x003fffff);                  paddr = (pde & CPU_PDE_4M_BASEADDR_MASK) + (laddr & 0x003fffff);
         } else {          } else
   #endif  /* CPU_FAMILY >= 5 */
           {
                 /* 4KB page size */                  /* 4KB page size */
                 pte_addr = (pde & CPU_PDE_BASEADDR_MASK) | ((laddr >> 10) & 0xffc);                  pte_addr = (pde & CPU_PDE_BASEADDR_MASK) + ((laddr >> 10) & 0xffc);
                 pte = cpu_memoryread_d(pte_addr);                  pte = cpu_memoryread_d(pte_addr);
                 if (!(pte & CPU_PTE_PRESENT)) {                  if (!(pte & CPU_PTE_PRESENT)) {
                         VERBOSE(("paging: PTE is not present"));                          VERBOSE(("paging: page is not present"));
                         VERBOSE(("paging: laddr = 0x%08x, pde_addr = 0x%08x, pde = 0x%08x", laddr, pde_addr, pde));                          VERBOSE(("paging: laddr = 0x%08x, pde_addr = 0x%08x, pde = 0x%08x", laddr, pde_addr, pde));
                         VERBOSE(("paging: pte_addr = 0x%08x, pte = 0x%08x", pte_addr, pte));                          VERBOSE(("paging: pte_addr = 0x%08x, pte = 0x%08x", pte_addr, pte));
                         err = 0;                          err = 0;
Line 404  paging(DWORD laddr, int crw, int user_mo Line 387  paging(DWORD laddr, int crw, int user_mo
                 }                  }
   
                 /* make physical address */                  /* make physical address */
                 paddr = (pte & CPU_PTE_BASEADDR_MASK) | (laddr & 0x00000fff);                  paddr = (pte & CPU_PTE_BASEADDR_MASK) + (laddr & 0x00000fff);
         }          }
   
         bit  = crw & CPU_PAGING_PAGE_WRITE;          bit  = crw & CPU_PAGE_WRITE;
         bit |= (pde & pte & (CPU_PTE_WRITABLE|CPU_PTE_USER_MODE));          bit |= (pde & pte & (CPU_PTE_WRITABLE|CPU_PTE_USER_MODE));
         bit |= (user_mode << 3);          bit |= (user_mode << 3);
         bit |= (CPU_CR0 & CPU_CR0_WP) >> 12;          bit |= CPU_STAT_WP;
   
 #if !defined(USE_PAGE_ACCESS_TABLE)  #if !defined(USE_PAGE_ACCESS_TABLE)
         if (!(page_access & (1 << bit)))          if (!(page_access & (1 << bit)))
Line 426  paging(DWORD laddr, int crw, int user_mo Line 409  paging(DWORD laddr, int crw, int user_mo
                 goto pf_exception;                  goto pf_exception;
         }          }
   
         if ((crw & CPU_PAGING_PAGE_WRITE) && !(pte & CPU_PTE_DIRTY)) {          if ((crw & CPU_PAGE_WRITE) && !(pte & CPU_PTE_DIRTY)) {
                 pte |= CPU_PTE_DIRTY;                  pte |= CPU_PTE_DIRTY;
                 cpu_memorywrite_d(pte_addr, pte);                  cpu_memorywrite_d(pte_addr, pte);
         }          }
Line 439  paging(DWORD laddr, int crw, int user_mo Line 422  paging(DWORD laddr, int crw, int user_mo
   
 pf_exception:  pf_exception:
         CPU_CR2 = laddr;          CPU_CR2 = laddr;
         err |= ((crw & CPU_PAGING_PAGE_WRITE) << 1) | (user_mode << 2);          err |= ((crw & CPU_PAGE_WRITE) << 1) | (user_mode << 2);
         EXCEPTION(PF_EXCEPTION, err);          EXCEPTION(PF_EXCEPTION, err);
         return 0;       /* compiler happy */          return 0;       /* compiler happy */
 }  }
Line 449  pf_exception: Line 432  pf_exception:
  * TLB   * TLB
  */   */
 typedef struct {  typedef struct {
         BYTE    valid;  /* TLB entry is valid */          UINT8   valid;  /* TLB entry is valid */
         BYTE    global; /* this TLB entry is global */          UINT8   global; /* this TLB entry is global */
         BYTE    score;          UINT8   score;
         BYTE    pad;          UINT8   pad;
   
         DWORD   tag;          UINT32  tag;
         DWORD   mask;   /* 4K or 2M or 4M */          UINT32  mask;   /* 4K or 2M or 4M */
   
         DWORD   paddr;  /* physical addr */          UINT32  paddr;  /* physical addr */
 } TLB_ENTRY_T;  } TLB_ENTRY_T;
   
 typedef struct {  typedef struct {
         BYTE            kind;          UINT8           kind;
 #define TLB_KIND_INSTRUCTION    (1 << 1)  #define TLB_KIND_INSTRUCTION    (1 << 1)
 #define TLB_KIND_DATA           (1 << 2)  #define TLB_KIND_DATA           (1 << 2)
 #define TLB_KIND_COMBINE        (TLB_KIND_INSTRUCTION|TLB_KIND_DATA)  #define TLB_KIND_COMBINE        (TLB_KIND_INSTRUCTION|TLB_KIND_DATA)
Line 469  typedef struct { Line 452  typedef struct {
 #define TLB_KIND_LARGE          (1 << 4)  #define TLB_KIND_LARGE          (1 << 4)
 #define TLB_KIND_BOTH           (TLB_KIND_SMALL|TLB_KIND_LARGE)  #define TLB_KIND_BOTH           (TLB_KIND_SMALL|TLB_KIND_LARGE)
   
         BYTE            way;    /* n-way associative */          UINT8           way;    /* n-way associative */
         BYTE            idx;    /* number of TLB index */          UINT8           idx;    /* number of TLB index */
         BYTE            bpad;          UINT8           bpad;
   
         WORD            num;    /* number of TLB entry */          UINT16          num;    /* number of TLB entry */
         WORD            wpad;          UINT16          wpad;
   
         TLB_ENTRY_T*    entry;  /* entry[assoc][idx] or entry[assoc] if idx == 1*/          TLB_ENTRY_T     *entry; /* entry[assoc][idx] or entry[assoc] if idx == 1*/
 } TLB_T;  } TLB_T;
   
 static int ntlb;  static int ntlb;
Line 484  static TLB_T tlb[4]; /* i TLB, i (lp) TL Line 467  static TLB_T tlb[4]; /* i TLB, i (lp) TL
   
 #if defined(IA32_PROFILE_TLB)  #if defined(IA32_PROFILE_TLB)
 /* profiling */  /* profiling */
 static DWORD tlb_hits;  static UINT64 tlb_hits;
 static DWORD tlb_misses;  static UINT64 tlb_misses;
 static DWORD tlb_lookups;  static UINT64 tlb_lookups;
 static DWORD tlb_updates;  static UINT64 tlb_updates;
 static DWORD tlb_flushes;  static UINT64 tlb_flushes;
 static DWORD tlb_global_flushes;  static UINT64 tlb_global_flushes;
 static DWORD tlb_entry_flushes;  static UINT64 tlb_entry_flushes;
   
 #define PROFILE_INC(v)  (v)++;  #define PROFILE_INC(v)  (v)++;
 #else   /* !IA32_PROFILE_TLB */  #else   /* !IA32_PROFILE_TLB */
Line 498  static DWORD tlb_entry_flushes; Line 481  static DWORD tlb_entry_flushes;
 #endif  /* IA32_PROFILE_TLB */  #endif  /* IA32_PROFILE_TLB */
   
 void  void
 tlb_init()  tlb_init(void)
 {  {
         int i;          int i;
   
Line 519  tlb_init() Line 502  tlb_init()
         tlb_entry_flushes = 0;          tlb_entry_flushes = 0;
 #endif  /* IA32_PROFILE_TLB */  #endif  /* IA32_PROFILE_TLB */
   
         /* XXX プロセッサ種別にしたがって TLB 構成を構築する */  #if CPU_FAMILY == 4
   
         /* とりあえず i486 形式で… */          /* とりあえず i486 形式で… */
         /* combine (I/D) TLB: 4KB Pages, 4-way set associative 32 entries */          /* combine (I/D) TLB: 4KB Pages, 4-way set associative 32 entries */
         ntlb = 1;          ntlb = 1;
         tlb[0].kind = TLB_KIND_COMBINE | TLB_KIND_SMALL;          tlb[0].kind = TLB_KIND_COMBINE | TLB_KIND_SMALL;
         tlb[0].num = 32;          tlb[0].num = 32;
         tlb[0].way = 4;          tlb[0].way = 4;
         tlb[0].idx = tlb[0].num / tlb[0].way;  #endif
   
         for (i = 0; i < ntlb; i++) {          for (i = 0; i < ntlb; i++) {
                   tlb[i].idx = tlb[i].num / tlb[i].way;
   
                 tlb[i].entry = (TLB_ENTRY_T*)calloc(sizeof(TLB_ENTRY_T), tlb[i].num);                  tlb[i].entry = (TLB_ENTRY_T*)calloc(sizeof(TLB_ENTRY_T), tlb[i].num);
                 if (tlb[i].entry == 0) {                  if (tlb[i].entry == 0) {
                         ia32_panic("tlb_init(): can't alloc TLB entry\n");                          ia32_panic("tlb_init(): can't alloc TLB entry\n");
Line 540  tlb_init() Line 524  tlb_init()
 void  void
 tlb_flush(BOOL allflush)  tlb_flush(BOOL allflush)
 {  {
         TLB_ENTRY_T* ep;          TLB_ENTRY_T *ep;
         int i, j;          int i, j;
   
         if (allflush) {          if (allflush) {
Line 561  tlb_flush(BOOL allflush) Line 545  tlb_flush(BOOL allflush)
 }  }
   
 void  void
 tlb_flush_page(DWORD vaddr)  tlb_flush_page(UINT32 vaddr)
 {  {
         TLB_ENTRY_T* ep;          TLB_ENTRY_T *ep;
         int idx;          int idx;
         int i;          int i;
   
Line 594  tlb_flush_page(DWORD vaddr) Line 578  tlb_flush_page(DWORD vaddr)
 }  }
   
 static BOOL  static BOOL
 tlb_lookup(DWORD laddr, int crw, DWORD* paddr)  tlb_lookup(UINT32 laddr, int crw, UINT32 *paddr)
 {  {
         TLB_ENTRY_T* ep;          TLB_ENTRY_T *ep;
         int idx;          int idx;
         int i;          int i;
   
         PROFILE_INC(tlb_lookups);          PROFILE_INC(tlb_lookups);
   
         crw &= CPU_PAGING_PAGE_CODE | CPU_PAGING_PAGE_DATA;          crw &= CPU_PAGE_CODE | CPU_PAGE_DATA;
         for (i = 0; i < ntlb; i++) {          for (i = 0; i < ntlb; i++) {
                 if (tlb[i].kind & crw) {                  if (tlb[i].kind & crw) {
                         if (tlb[i].idx == 1) {                          if (tlb[i].idx == 1) {
Line 621  tlb_lookup(DWORD laddr, int crw, DWORD*  Line 605  tlb_lookup(DWORD laddr, int crw, DWORD* 
                         for (i = 0; i < tlb[i].way; i++) {                          for (i = 0; i < tlb[i].way; i++) {
                                 if (ep->valid) {                                  if (ep->valid) {
                                         if ((laddr & ep->mask) == ep->tag) {                                          if ((laddr & ep->mask) == ep->tag) {
                                                 if (ep->score != (BYTE)~0)                                                  if (ep->score != (UINT8)~0)
                                                         ep->score++;                                                          ep->score++;
                                                 *paddr = ep->paddr;                                                  *paddr = ep->paddr;
                                                 PROFILE_INC(tlb_hits);                                                  PROFILE_INC(tlb_hits);
Line 636  tlb_lookup(DWORD laddr, int crw, DWORD*  Line 620  tlb_lookup(DWORD laddr, int crw, DWORD* 
 }  }
   
 static void  static void
 tlb_update(DWORD paddr, DWORD entry, int crw)  tlb_update(UINT32 paddr, UINT entry, int crw)
 {  {
         TLB_ENTRY_T* ep;          TLB_ENTRY_T *ep;
         int idx;          int idx;
         int i, j;          int i, j;
         int min_way;          int min_way;
         WORD min_score = ~0;          UINT16 min_score = ~0;
   
         PROFILE_INC(tlb_updates);          PROFILE_INC(tlb_updates);
   
         crw &= CPU_PAGING_PAGE_CODE | CPU_PAGING_PAGE_DATA;          crw &= CPU_PAGE_CODE | CPU_PAGE_DATA;
         for (i = 0; i < ntlb; i++) {          for (i = 0; i < ntlb; i++) {
                 if (tlb[i].kind & crw) {                  if (tlb[i].kind & crw) {
                         if (tlb[i].idx == 1) {                          if (tlb[i].idx == 1) {
Line 693  tlb_update(DWORD paddr, DWORD entry, int Line 677  tlb_update(DWORD paddr, DWORD entry, int
         }          }
         __ASSERT(i != ntlb);          __ASSERT(i != ntlb);
 }  }
 #else   /* !IA32_SUPPORT_TLB */  
 void  
 tlb_init()  
 {  
   
         /* nothing to do */  
 }  
   
 void  
 tlb_flush(BOOL allflush)  
 {  
   
         (void)allflush;  
 }  
   
 void  
 tlb_flush_page(DWORD laddr)  
 {  
   
         (void)laddr;  
 }  
 #endif  /* IA32_SUPPORT_TLB */  #endif  /* IA32_SUPPORT_TLB */
Removed from v.1.7  
changed lines
  Added in v.1.12

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