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

Diff for /np2/i386c/ia32/segments.h between versions 1.4 and 1.6

version 1.4, 2004/01/27 15:55:26 version 1.6, 2004/02/05 16:43:44
Line 35  extern "C" { Line 35  extern "C" {
 #endif  #endif
   
 /*  /*
  * segment selector  
  */  
 #define CPU_SEGMENT_SELECTOR_INDEX_MASK ~7  
 #define CPU_SEGMENT_SELECTOR_RPL_MASK   3  
 #define CPU_SEGMENT_TABLE_IND           (1 << 2)        /* 0 = GDT, 1 = LDT */  
   
   
 /*  
  * segment descriptor   * segment descriptor
  */   */
 typedef struct {  typedef struct {
Line 69  typedef struct { Line 61  typedef struct {
                 } gate;                  } gate;
         } u;          } u;
   
         DWORD   addr;   /* descriptor addr */  
         DWORD   l;      /* low dword cache */  
         DWORD   h;      /* high dword cache */  
   
         BYTE    valid;  /* descriptor valid flag */          BYTE    valid;  /* descriptor valid flag */
         BYTE    p;      /* avail flag */          BYTE    p;      /* avail flag */
   
         BYTE    type;   /* descriptor type */          BYTE    type;   /* descriptor type */
         BYTE    dpl;    /* DPL */          BYTE    dpl;    /* DPL */
           BYTE    rpl;    /* RPL */
         BYTE    s;      /* 0 = system, 1 = code/data */          BYTE    s;      /* 0 = system, 1 = code/data */
         BYTE    d;      /* 0 = 16bit, 1 = 32bit */          BYTE    d;      /* 0 = 16bit, 1 = 32bit */
   
         BYTE    flag;          BYTE    flag;
 #define CPU_DESC_FLAG_READABLE  (1 << 0)  #define CPU_DESC_FLAG_READABLE  (1 << 0)
 #define CPU_DESC_FLAG_WRITABLE  (1 << 1)  #define CPU_DESC_FLAG_WRITABLE  (1 << 1)
   
         BYTE    b_pad;  
 } descriptor_t;  } descriptor_t;
   
   
Line 118  typedef struct { Line 105  typedef struct {
 #define CPU_GATEDESC_H_D        (  1 << 11)  #define CPU_GATEDESC_H_D        (  1 << 11)
   
 /* for tss descriptor */  /* for tss descriptor */
 #define CPU_TSS_H_BUSY          (  1 << 10)  #define CPU_TSS_H_BUSY          (  1 <<  9)
   
 /*  /*
  * descriptor type   * descriptor type
Line 159  do { \ Line 146  do { \
         (dscp)->u.seg.g = 0; \          (dscp)->u.seg.g = 0; \
         (dscp)->valid = 1; \          (dscp)->valid = 1; \
         (dscp)->p = 1; \          (dscp)->p = 1; \
         (dscp)->type = 0x02 /* writable */; \          (dscp)->type = 0x02; /* writable */ \
         (dscp)->dpl = 0; \          (dscp)->dpl = 0; \
         (dscp)->s = 1;  /* code/data */ \          (dscp)->s = 1;  /* code/data */ \
         (dscp)->d = 0; \          (dscp)->d = 0; /* 16bit */ \
         (dscp)->flag = 0; \          (dscp)->flag = CPU_DESC_FLAG_READABLE|CPU_DESC_FLAG_WRITABLE; \
 } while (/*CONSTCOND*/ 0)  } while (/*CONSTCOND*/ 0)
   
 #define CPU_SET_SEGDESC_POSTPART(dscp) \  #define CPU_SET_TASK_BUSY(selector, dscp) \
 do { \  do { \
         if ((dscp)->valid) { \          DWORD addr; \
                 if ((dscp)->s) { \          DWORD h; \
                         if (!((dscp)->h & CPU_SEGDESC_H_A)) { \          addr = CPU_GDTR_BASE + ((selector) & CPU_SEGMENT_SELECTOR_INDEX_MASK); \
                                 (dscp)->h |= CPU_SEGDESC_H_A; \          h = cpu_kmemoryread_d(addr + 4); \
                                 cpu_lmemorywrite_d((dscp)->addr+4, (dscp)->h); \          if (!(h & CPU_TSS_H_BUSY)) { \
                         } \                  (dscp)->type |= CPU_SYSDESC_TYPE_TSS_BUSY_IND; \
                 } \                  h |= CPU_TSS_H_BUSY; \
                   cpu_kmemorywrite_d(addr + 4, h); \
         } else { \          } else { \
                 ia32_panic("CPU_SET_SEGDESC_POSTPART: descriptor is invalid"); \                  ia32_panic("CPU_SET_TASK_BUSY: already busy (%04x:%08x)", selector, h); \
         } \          } \
 } while (/*CONSTCOND*/ 0)  } while (/*CONSTCOND*/ 0)
   
 #define CPU_SET_TASK_BUSY(dscp) \  #define CPU_SET_TASK_FREE(selector, dscp) \
 do { \  do { \
         if ((dscp)->valid) { \          DWORD addr; \
                 DWORD h; \          DWORD h; \
                 h = cpu_lmemoryread_d((dscp)->addr + 4); \          addr = CPU_GDTR_BASE + ((selector) & CPU_SEGMENT_SELECTOR_INDEX_MASK); \
                 if (!(h & CPU_TSS_H_BUSY)) { \          h = cpu_kmemoryread_d(addr + 4); \
                         (dscp)->type |= CPU_SYSDESC_TYPE_TSS_BUSY_IND; \          if (h & CPU_TSS_H_BUSY) { \
                         h |= CPU_TSS_H_BUSY; \                  (dscp)->type &= ~CPU_SYSDESC_TYPE_TSS_BUSY_IND; \
                         cpu_lmemorywrite_d((dscp)->addr + 4, h); \                  h &= ~CPU_TSS_H_BUSY; \
                 } else { \                  cpu_kmemorywrite_d(addr + 4, h); \
                         ia32_panic("CPU_SET_TASK_BUSY: already busy (%x)", h); \  
                 } \  
         } else { \          } else { \
                 ia32_panic("CPU_SET_TASK_BUSY: descriptor is invalid"); \                  ia32_panic("CPU_SET_TASK_FREE: already free (%04x:%08x)", selector, h); \
         } \          } \
 } while (/*CONSTCOND*/ 0)  } while (/*CONSTCOND*/ 0)
   
 #define CPU_SET_TASK_FREE(dscp) \  void load_descriptor(descriptor_t *descp, DWORD addr);
 do { \  
         if ((dscp)->valid) { \  #define CPU_SET_SEGREG(idx, selector)   load_segreg(idx, selector, GP_EXCEPTION)
                 DWORD h; \  void load_segreg(int idx, WORD selector, int exc);
                 h = cpu_lmemoryread_d((dscp)->addr + 4); \  void load_ss(WORD selector, descriptor_t* sdp, DWORD cpl);
                 if (h & CPU_TSS_H_BUSY) { \  void load_cs(WORD selector, descriptor_t* sdp, DWORD cpl);
                         (dscp)->type &= ~CPU_SYSDESC_TYPE_TSS_BUSY_IND; \  void load_ldtr(WORD selector, int exc);
                         h &= ~CPU_TSS_H_BUSY; \  
                         cpu_lmemorywrite_d((dscp)->addr + 4, h); \  
                 } else { \  /*
                         ia32_panic("CPU_SET_TASK_FREE: already free (%x)", h); \   * segment selector
                 } \   */
         } else { \  #define CPU_SEGMENT_SELECTOR_INDEX_MASK (~7)
                 ia32_panic("CPU_SET_TASK_FREE: descriptor is invalid"); \  #define CPU_SEGMENT_SELECTOR_RPL_MASK   (3)
         } \  #define CPU_SEGMENT_TABLE_IND           (1 << 2)        /* 0 = GDT, 1 = LDT */
 } while (/*CONSTCOND*/ 0)  
   
 typedef struct {  typedef struct {
         WORD            selector;          WORD            selector;
Line 221  typedef struct { Line 206  typedef struct {
         BYTE            ldt;          BYTE            ldt;
         BYTE            pad;          BYTE            pad;
   
           DWORD           addr;           /* descriptor linear address */
   
         descriptor_t    desc;          descriptor_t    desc;
 } selector_t;  } selector_t;
   
 int parse_selector(selector_t* ssp, WORD selector);  int parse_selector(selector_t *ssp, WORD selector);
 int selector_is_not_present(selector_t* ssp);  int selector_is_not_present(selector_t *ssp);
   
 #define CPU_SET_SEGDESC(descp, addr)    load_descriptor(descp, addr)  
 #define CPU_SET_GATEDESC(descp, addr)   load_descriptor(descp, addr)  
 void load_descriptor(descriptor_t* descp, DWORD addr);  
   
 #define CPU_SET_SEGREG(idx, selector)   load_segreg(idx, selector, GP_EXCEPTION)  
 void load_segreg(int idx, WORD selector, int exc);  
 void load_ss(WORD selector, descriptor_t* sdp, BYTE cpl);  
 void load_cs(WORD selector, descriptor_t* sdp, BYTE cpl);  
 void load_ldtr(WORD selector, int exc);  
   
 #ifdef __cplusplus  #ifdef __cplusplus
 }  }
Removed from v.1.4  
changed lines
  Added in v.1.6

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