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

Diff for /np2/i386c/ia32/debug.c between versions 1.5 and 1.17

version 1.5, 2004/01/26 15:23:55 version 1.17, 2011/12/20 01:16:25
Line 1 Line 1
 /*      $Id$    */  
   
 /*  /*
  * Copyright (c) 2002-2003 NONAKA Kimihiro   * Copyright (c) 2002-2003 NONAKA Kimihiro
  * All rights reserved.   * All rights reserved.
Line 12 Line 10
  * 2. Redistributions in binary form must reproduce the above copyright   * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the   *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.   *    documentation and/or other materials provided with the distribution.
  * 3. The name of the author may not be used to endorse or promote products  
  *    derived from this software without specific prior written permission.  
  *   *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR   * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES   * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
Line 31 Line 27
   
 #include "cpu.h"  #include "cpu.h"
 #include "memory.h"  #include "memory.h"
 #ifdef USE_FPU  #if defined(USE_FPU)
 #include "instructions/fpu/fpu.h"  #include "instructions/fpu/fp.h"
 #endif  
   
   
 char *cpu_reg2str(void)  
 {  
   static char buf[512];  
   
   sprintf(buf,  
     "eax=%08x ebx=%08x ecx=%08x edx=%08x esi=%08x edi=%08x\n"  
     "eip=%08x esp=%08x ebp=%08x prev_eip=%08x\n"  
     "cs=%04x  ss=%04x  ds=%04x  es=%04x  fs=%04x  gs=%04x\n"  
     "eflag=%08x "  
 /* ID VIP VIF AC VM RF NT IOPL OF DF IF TF SF ZF AF PF CF */  
       "[ ID=%d VIP=%d VIF=%d AC=%d VM=%d RF=%d NT=%d IOPL=%d%d %s %s %s TF=%d %s %s %s %s %s ]\n"  
     "gdtr=%08x:%04x idtr=%08x:%04x\n"  
     "ldtr=%04x(%08x:%04x) tr=%04x(%08x:%04x)\n"  
     "cr0=%08x cr1=%08x cr2=%08x cr3=%08x cr4=%08x mxcsr=%08x",  
     CPU_EAX, CPU_EBX, CPU_ECX, CPU_EDX, CPU_ESI, CPU_EDI,  
     CPU_EIP, CPU_ESP, CPU_EBP, CPU_PREV_EIP,  
     CPU_CS, CPU_SS, CPU_DS, CPU_ES, CPU_FS, CPU_GS,  
     CPU_EFLAG,  
       (CPU_EFLAG & ID_FLAG) != 0,  
       (CPU_EFLAG & VIP_FLAG) != 0,  
       (CPU_EFLAG & VIF_FLAG) != 0,  
       (CPU_EFLAG & AC_FLAG) != 0,  
       (CPU_EFLAG & VM_FLAG) != 0,  
       (CPU_EFLAG & RF_FLAG) != 0,  
       (CPU_EFLAG & NT_FLAG) != 0,  
       CPU_EFLAG >> 13 & 1,  
       CPU_EFLAG >> 12 & 1,  
       CPU_EFLAG & O_FLAG ? "OV" : "NV",  
       CPU_EFLAG & D_FLAG ? "UP" : "DN",  
       CPU_EFLAG & I_FLAG ? "DI" : "EI",  
       (CPU_EFLAG & T_FLAG) != 0,  
       CPU_EFLAG & S_FLAG ? "NG" : "PL",  
       CPU_EFLAG & Z_FLAG ? "ZR" : "NZ",  
       CPU_EFLAG & A_FLAG ? "AC" : "NA",  
       CPU_EFLAG & P_FLAG ? "PE" : "PO",  
       CPU_EFLAG & C_FLAG ? "CY" : "NC",  
     CPU_GDTR_BASE, CPU_GDTR_LIMIT, CPU_IDTR_BASE, CPU_IDTR_LIMIT,  
     CPU_LDTR, CPU_LDTR_BASE, CPU_LDTR_LIMIT, CPU_TR, CPU_TR_BASE, CPU_TR_LIMIT,  
     CPU_CR0, CPU_CR1, CPU_CR2, CPU_CR3, CPU_CR4, CPU_MXCSR);  
   
   return buf;  
 }  
   
 #ifdef USE_FPU  
 char *fpu_reg2str(void)  
 {  
   static char buf[512];  
   char tmp[128];  
   int i;  
   int no;  
   
   strcpy(buf, "st=\n");  
   for(no = 0; no < 8; no++)  
   {  
     for(i = 9; i >= 0; i--)  
     {  
       sprintf(tmp, "%02x", FPU_ST[no][i]);  
       strcat(buf, tmp);  
     }  
     strcat(buf, "\n");  
   }  
   
   sprintf(tmp,  
     "ctrl=%04x  status=%04x  tag=%04x\n"  
     "inst=%08x%04x  data=%08x%04x  op=%03x\n",  
     FPU_CTRLWORD,  
     FPU_STATUSWORD,  
     FPU_TAGWORD,  
     FPU_INSTPTR_OFFSET, FPU_INSTPTR_SEG,  
     FPU_DATAPTR_OFFSET, FPU_DATAPTR_SEG,  
     FPU_LASTINSTOP);  
   strcat(buf, tmp);  
   
   return buf;  
 }  
 #endif  #endif
   
 static char *a20str(void)  
 {  
   static char buf[32];  
   
   sprintf(buf, "a20line=%s\n", CPU_STAT_ADRSMASK == 0xffffffff ? "enable" : "disable");  
   return buf;  
 }  
   
 static char *mem2str(DWORD cs, DWORD ip)  
 {  
   static char buf[128];  
   char tmp[16];  
   int i;  
   
   strcpy(buf, "mem=... ");  
   for(i = -10; i < 0; i++)  
   {  
     sprintf(tmp, "%02x ", __i286_memoryread((cs << 4) + ip + i));  
     strcat(buf, tmp);  
   }  
   sprintf(tmp, "<%02x> ", __i286_memoryread((cs << 4) + ip));  
   strcat(buf, tmp);  
   for(i = 1; i <= 10; i++)  
   {  
     sprintf(tmp, "%02x ", __i286_memoryread((cs << 4) + ip + i));  
     strcat(buf, tmp);  
   }  
   strcat(buf, "...\n");  
   
   return buf;  
 }  
   
 void FASTCALL msgbox_str(char *msg)  char *
   cpu_reg2str(void)
 {  {
           static char buf[512];
   
   printf(msg);          snprintf(buf, sizeof(buf),
   fflush(stdout);              "eax=%08x ecx=%08x edx=%08x ebx=%08x\n"
   exit(1);              "esp=%08x ebp=%08x esi=%08x edi=%08x\n"
               "eip=%08x prev_eip=%08x\n"
               "es=%04x cs=%04x ss=%04x ds=%04x fs=%04x gs=%04x\n"
               "eflag=%08x "
               /* ID VIP VIF AC VM RF NT IOPL OF DF IF TF SF ZF AF PF CF */
               "[ ID=%d VIP=%d VIF=%d AC=%d VM=%d RF=%d NT=%d IOPL=%d %s %s %s TF=%d %s %s %s %s %s ]\n"
               "gdtr=%08x:%04x idtr=%08x:%04x\n"
               "ldtr=%04x(%08x:%04x) tr=%04x(%08x:%04x)\n"
               "cr0=%08x cr1=%08x cr2=%08x cr3=%08x cr4=%08x mxcsr=%08x",
               CPU_EAX, CPU_ECX, CPU_EDX, CPU_EBX,
               CPU_ESP, CPU_EBP,CPU_ESI, CPU_EDI,
               CPU_EIP, CPU_PREV_EIP,
               CPU_CS, CPU_SS, CPU_DS, CPU_ES, CPU_FS, CPU_GS,
               CPU_EFLAG,
               (CPU_EFLAG & ID_FLAG) != 0,
               (CPU_EFLAG & VIP_FLAG) != 0,
               (CPU_EFLAG & VIF_FLAG) != 0,
               (CPU_EFLAG & AC_FLAG) != 0,
               (CPU_EFLAG & VM_FLAG) != 0,
               (CPU_EFLAG & RF_FLAG) != 0,
               (CPU_EFLAG & NT_FLAG) != 0,
               (int)((CPU_EFLAG >> 12) & 3),
               CPU_OV ? "OV" : "NV",
               CPU_EFLAG & D_FLAG ? "UP" : "DN",
               CPU_EFLAG & I_FLAG ? "DI" : "EI",
               (CPU_EFLAG & T_FLAG) != 0,
               CPU_EFLAG & S_FLAG ? "NG" : "PL",
               CPU_EFLAG & Z_FLAG ? "ZR" : "NZ",
               CPU_EFLAG & A_FLAG ? "AC" : "NA",
               CPU_EFLAG & P_FLAG ? "PE" : "PO",
               CPU_EFLAG & C_FLAG ? "CY" : "NC",
               CPU_GDTR_BASE, CPU_GDTR_LIMIT, CPU_IDTR_BASE, CPU_IDTR_LIMIT,
               CPU_LDTR, CPU_LDTR_BASE, CPU_LDTR_LIMIT,
                 CPU_TR, CPU_TR_BASE, CPU_TR_LIMIT,
               CPU_CR0, CPU_CR1, CPU_CR2, CPU_CR3, CPU_CR4, CPU_MXCSR);
   
           return buf;
   }
   
   static char *
   a20str(void)
   {
           static char buf[32];
   
           snprintf(buf, sizeof(buf), "a20line=%s\n",
               (CPU_STAT_ADRSMASK == 0xffffffff) ? "enable" : "disable");
           return buf;
 }  }
   
 void FASTCALL msgbox_mem(DWORD no)  void
   put_cpuinfo(void)
 {  {
   char buf[2048];          char buf[2048];
   char tmp[16];  
   
   strcpy(buf, cpu_reg2str());          strcpy(buf, cpu_reg2str());
   strcat(buf, "\n");          strcat(buf, "\n");
 #ifdef USE_FPU  #if defined(USE_FPU)
   strcat(buf, fpu_reg2str());          strcat(buf, fpu_reg2str());
   strcat(buf, "\n");          strcat(buf, "\n");
 #endif  #endif
   strcat(buf, mem2str(CPU_CS, CPU_IP));          strcat(buf, a20str());
   strcat(buf, "\n");  
   sprintf(tmp, "no=%08x\n", no);  
   strcat(buf, tmp);  
   
   msgbox_str(buf);          printf(buf);
 }  }
   
 void put_cpuinfo(void)  void
   dbg_printf(const char *str, ...)
 {  {
   char buf[2048];          char buf[1024];
           va_list ap;
   
   strcpy(buf, cpu_reg2str());          va_start(ap, str);
   strcat(buf, "\n");          vsnprintf(buf, sizeof(buf), str, ap);
 #ifdef USE_FPU          va_end(ap);
   strcat(buf, fpu_reg2str());          strcat(buf, "\n");
   strcat(buf, "\n");  
 #endif  
   strcat(buf, a20str());  
   
   printf(buf);          printf(buf);
 }  }
   
 void  void
 memory_dump(int idx, DWORD madr)  memory_dump(int idx, UINT32 madr)
 {  {
         DWORD addr;          UINT32 addr;
         size_t size;          size_t size;
         unsigned char buf[16];  
         size_t s, i;          size_t s, i;
         BYTE p;          UINT8 buf[16];
           UINT8 c;
   
         if (madr < 0x80) {          if (madr < 0x80) {
                 size = madr + 0x80;                  size = madr + 0x80;
Line 203  memory_dump(int idx, DWORD madr) Line 134  memory_dump(int idx, DWORD madr)
                 size = 0x100;                  size = 0x100;
                 addr = madr - 0x80;                  addr = madr - 0x80;
         }          }
         VERBOSE(("memory dump\n-- \n"));          VERBOSE(("memory dump\n--"));
         for (s = 0; s < size; s++) {          for (s = 0; s < size; s++) {
                 if ((s % 16) == 0) {                  if ((s % 16) == 0) {
                         VERBOSE(("%08x: ", addr + s));                          VERBOSE(("%08x: ", addr + s));
                         memset(buf, '.', sizeof(buf));                          memset(buf, '.', sizeof(buf));
                 }                  }
   
                 p = cpu_vmemoryread(idx, addr + s);                  c = cpu_vmemoryread(idx, addr + s);
                 VERBOSE(("%02x ", p));                  VERBOSE(("%02x ", c));
                 if (p >= 0x20 && p <= 0x7e)                  if (c >= 0x20 && c <= 0x7e)
                         buf[s % 16] = p;                          buf[s % 16] = c;
   
                 if ((s % 16) == 15) {                  if ((s % 16) == 15) {
                         VERBOSE(("| "));                          VERBOSE(("| "));
Line 225  memory_dump(int idx, DWORD madr) Line 156  memory_dump(int idx, DWORD madr)
 }  }
   
 void  void
 gdtr_dump(DWORD base, DWORD limit)  gdtr_dump(UINT32 base, UINT limit)
 {  {
         DWORD v[2];          UINT32 v[2];
         DWORD i;          UINT i;
   
         VERBOSE(("GDTR_DUMP: GDTR_BASE = 0x%08x, GDTR_LIMIT = 0x%04x",base,limit));          VERBOSE(("GDTR_DUMP: GDTR_BASE = 0x%08x, GDTR_LIMIT = 0x%04x", base, limit));
   
         for (i = 0; i < limit; i += 8) {          for (i = 0; i < limit; i += 8) {
                 v[0] = cpu_lmemoryread_d(base + i);                  v[0] = cpu_kmemoryread_d(base + i);
                 v[1] = cpu_lmemoryread_d(base + i + 4);                  v[1] = cpu_kmemoryread_d(base + i + 4);
                 VERBOSE(("GDTR_DUMP: %08x: %08x%08x", base + i, v[0], v[1]));                  VERBOSE(("GDTR_DUMP: %08x: %08x%08x", base + i, v[0], v[1]));
         }          }
 }  }
   
 void  void
 ldtr_dump(DWORD base, DWORD limit)  ldtr_dump(UINT32 base, UINT limit)
 {  {
         DWORD v[2];          UINT32 v[2];
         DWORD i;          UINT i;
   
         VERBOSE(("LDTR_DUMP: LDTR_BASE = 0x%08x, LDTR_LIMIT = 0x%04x",base,limit));          VERBOSE(("LDTR_DUMP: LDTR_BASE = 0x%08x, LDTR_LIMIT = 0x%04x", base, limit));
   
         for (i = 0; i < limit; i += 8) {          for (i = 0; i < limit; i += 8) {
                 v[0] = cpu_lmemoryread_d(base + i);                  v[0] = cpu_kmemoryread_d(base + i);
                 v[1] = cpu_lmemoryread_d(base + i + 4);                  v[1] = cpu_kmemoryread_d(base + i + 4);
                 VERBOSE(("LDTR_DUMP: %08x: %08x%08x", base + i, v[0], v[1]));                  VERBOSE(("LDTR_DUMP: %08x: %08x%08x", base + i, v[0], v[1]));
         }          }
 }  }
   
 void  void
 idtr_dump(DWORD base, DWORD limit)  idtr_dump(UINT32 base, UINT limit)
 {  {
         DWORD v[2];          UINT32 v[2];
         DWORD i;          UINT i;
   
         VERBOSE(("IDTR_DUMP: IDTR_BASE = 0x%08x, IDTR_LIMIT = 0x%04x",base,limit));          VERBOSE(("IDTR_DUMP: IDTR_BASE = 0x%08x, IDTR_LIMIT = 0x%04x", base, limit));
   
         for (i = 0; i < limit; i += 8) {          for (i = 0; i < limit; i += 8) {
                 v[0] = cpu_lmemoryread_d(base + i);                  v[0] = cpu_kmemoryread_d(base + i);
                 v[1] = cpu_lmemoryread_d(base + i + 4);                  v[1] = cpu_kmemoryread_d(base + i + 4);
                 VERBOSE(("IDTR_DUMP: %08x: %08x%08x", base + i, v[0], v[1]));                  VERBOSE(("IDTR_DUMP: %08x: %08x%08x", base + i, v[0], v[1]));
         }          }
 }  }
   
 void  void
 tr_dump(WORD selector, DWORD base, DWORD limit)  tr_dump(UINT16 selector, UINT32 base, UINT limit)
 {  {
         DWORD v;          UINT32 v;
         DWORD i;          UINT i;
   
         VERBOSE(("TR_DUMP: selector = %04x", selector));          VERBOSE(("TR_DUMP: selector = %04x", selector));
   
         for (i = 0; i < limit; i += 4) {          for (i = 0; i < limit; i += 4) {
                 v = cpu_lmemoryread_d(base + i);                  v = cpu_kmemoryread_d(base + i);
                 VERBOSE(("TR_DUMP: %08x: %08x", base + i, v));                  VERBOSE(("TR_DUMP: %08x: %08x", base + i, v));
         }          }
 }  }
   
 DWORD  UINT32
 pde_dump(DWORD base, int idx)  pde_dump(UINT32 base, int idx)
 {  {
         DWORD paddr;          UINT32 paddr;
         DWORD v;          UINT32 v;
         int i;          int i;
   
         if (idx < 0 && idx > -8192) {          if (idx < 0 && idx > -8192) {
Line 305  pde_dump(DWORD base, int idx) Line 236  pde_dump(DWORD base, int idx)
                 v = cpu_memoryread_d(paddr);                  v = cpu_memoryread_d(paddr);
                 VERBOSE(("PDE_DUMP: 0x%08x: %08x", paddr, v));                  VERBOSE(("PDE_DUMP: 0x%08x: %08x", paddr, v));
         } else {          } else {
                   VERBOSE(("PDE_DUMP: invalid idx (%d)", idx));
                 paddr = 0;                  paddr = 0;
         }          }
   
         return paddr;          return paddr;
 }  }
   
 DWORD  void
 convert_laddr_to_paddr(DWORD laddr)  segdesc_dump(descriptor_t *sdp)
   {
   #if defined(DEBUG)
           const char *s;
   
           __ASSERT(sdp != NULL);
   
           VERBOSE(("\ndump descriptor", sdp));
   
           VERBOSE(("valid    : %s", SEG_IS_VALID(sdp) ? "true" : "false"));
           VERBOSE(("present  : %s", SEG_IS_PRESENT(sdp) ? "true" : "false"));
           VERBOSE(("DPL      : %d", sdp->dpl));
           VERBOSE(("kind     : %s", SEG_IS_SYSTEM(sdp) ? "system" : "code/data"));
           if (!SEG_IS_SYSTEM(sdp)) {
                   if (SEG_IS_CODE(sdp)) {
                           VERBOSE(("type     : %sconforming code",
                               SEG_IS_CONFORMING_CODE(sdp) ? "" : "non-"));
                           VERBOSE(("access   : execute%s",
                               SEG_IS_READABLE_CODE(sdp) ? "/read" : ""));
                   } else {
                           VERBOSE(("type     : expand-%s data",
                               SEG_IS_EXPANDDOWN_DATA(sdp) ? "down" : "up"));
                           VERBOSE(("access   : read%s",
                               SEG_IS_WRITABLE_DATA(sdp) ? "/write" : ""));
                   }
                   VERBOSE(("4k scale : %s", sdp->u.seg.g ? "true" : "false"));
                   VERBOSE(("baseadr  : 0x%08x", sdp->u.seg.segbase));
                   VERBOSE(("limit    : 0x%08x", sdp->u.seg.limit));
           } else {
                   switch (sdp->type) {
                   case CPU_SYSDESC_TYPE_LDT:              /* LDT */
                           VERBOSE(("type     : LDT"));
                           VERBOSE(("4k scale : %s", sdp->u.seg.g ? "true" : "false"));
                           VERBOSE(("baseadr  : 0x%08x", sdp->u.seg.segbase));
                           VERBOSE(("limit    : 0x%08x", sdp->u.seg.limit));
                           break;
   
                   case CPU_SYSDESC_TYPE_TASK:             /* task gate */
                           VERBOSE(("type     : task gate"));
                           VERBOSE(("selector : 0x%04x", sdp->u.gate.selector));
                           break;
   
                   case CPU_SYSDESC_TYPE_TSS_16:           /* 286 TSS */
                   case CPU_SYSDESC_TYPE_TSS_BUSY_16:      /* 286 Busy TSS */
                   case CPU_SYSDESC_TYPE_TSS_32:           /* 386 TSS */
                   case CPU_SYSDESC_TYPE_TSS_BUSY_32:      /* 386 Busy TSS */
                           VERBOSE(("type     : %dbit %sTSS",
                               (sdp->type & CPU_SYSDESC_TYPE_32BIT) ? 32 : 16,
                               (sdp->type & CPU_SYSDESC_TYPE_TSS_BUSY_IND) ?
                                 "Busy " : ""));
                           VERBOSE(("4k scale : %s", sdp->u.seg.g ? "true" : "false"));
                           VERBOSE(("baseadr  : 0x%08x", sdp->u.seg.segbase));
                           VERBOSE(("limit    : 0x%08x", sdp->u.seg.limit));
                           break;
   
                   case CPU_SYSDESC_TYPE_CALL_16:          /* 286 call gate */
                   case CPU_SYSDESC_TYPE_INTR_16:          /* 286 interrupt gate */
                   case CPU_SYSDESC_TYPE_TRAP_16:          /* 286 trap gate */
                   case CPU_SYSDESC_TYPE_CALL_32:          /* 386 call gate */
                   case CPU_SYSDESC_TYPE_INTR_32:          /* 386 interrupt gate */
                   case CPU_SYSDESC_TYPE_TRAP_32:          /* 386 trap gate */
                           switch (sdp->type & CPU_SYSDESC_TYPE_MASKBIT) {
                           case CPU_SYSDESC_TYPE_CALL:
                                   s = "call";
                                   break;
   
                           case CPU_SYSDESC_TYPE_INTR:
                                   s = "interrupt";
                                   break;
   
                           case CPU_SYSDESC_TYPE_TRAP:
                                   s = "trap";
                                   break;
   
                           default:
                                   s = "unknown";
                                   break;
                           }
                           VERBOSE(("type     : %c86 %s gate",
                               (sdp->type & CPU_SYSDESC_TYPE_32BIT) ? '3':'2', s));
                           VERBOSE(("selector : 0x%04x", sdp->u.gate.selector));
                           VERBOSE(("offset   : 0x%08x", sdp->u.gate.offset));
                           VERBOSE(("count    : %d", sdp->u.gate.count));
                           break;
   
                   case 0: case 8: case 10: case 13: /* reserved */
                   default:
                           VERBOSE(("type     : unknown descriptor"));
                           break;
                   }
           }
   #endif
   }
   
   UINT32
   convert_laddr_to_paddr(UINT32 laddr)
 {  {
         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 */
   
         pde_addr = (CPU_CR3 & CPU_CR3_PD_MASK) | ((laddr >> 20) & 0xffc);          pde_addr = (CPU_CR3 & CPU_CR3_PD_MASK) | ((laddr >> 20) & 0xffc);
         pde = cpu_memoryread_d(pde_addr);          pde = cpu_memoryread_d(pde_addr);
Line 335  convert_laddr_to_paddr(DWORD laddr) Line 362  convert_laddr_to_paddr(DWORD laddr)
         return paddr;          return paddr;
 }  }
   
 DWORD  UINT32
 convert_vaddr_to_paddr(unsigned int idx, DWORD offset)  convert_vaddr_to_paddr(unsigned int idx, UINT32 offset)
 {  {
         descriptor_t *sdp;          descriptor_t *sdp;
         DWORD laddr;          UINT32 laddr;
   
         if (idx < CPU_SEGREG_NUM) {          if (idx < CPU_SEGREG_NUM) {
                 sdp = &CPU_STAT_SREG(idx);                  sdp = &CPU_STAT_SREG(idx);
                 if (sdp->valid) {                  if (SEG_IS_VALID(sdp)) {
                         laddr = CPU_STAT_SREGBASE(idx) + offset;                          laddr = CPU_STAT_SREGBASE(idx) + offset;
                         return convert_laddr_to_paddr(laddr);                          return convert_laddr_to_paddr(laddr);
                 }                  }
Removed from v.1.5  
changed lines
  Added in v.1.17

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