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

Diff for /np2/i386c/ia32/ctrlxfer.c between versions 1.1 and 1.8

version 1.1, 2003/12/08 00:55:31 version 1.8, 2004/02/05 16:43:44
Line 34 Line 34
 #include "ctrlxfer.h"  #include "ctrlxfer.h"
   
   
   /*------------------------------------------------------------------------------
    * JMPfar_pm
    */
   static void JMPfar_pm_code_segment(selector_t *jmp_sel, DWORD new_ip);
   static void JMPfar_pm_call_gate(selector_t *jmp_sel);
   static void JMPfar_pm_task_gate(selector_t *jmp_sel);
   static void JMPfar_pm_tss(selector_t *jmp_sel);
   
 void  void
 JMPfar_pm(WORD selector, DWORD new_ip)  JMPfar_pm(WORD selector, DWORD new_ip)
 {  {
         selector_t jmp_sel;          selector_t jmp_sel;
         selector_t sel2;  
         int rv;          int rv;
   
           VERBOSE(("JMPfar_pm: old EIP = %04x:%08x, ESP = %04x:%08x", CPU_CS, CPU_PREV_EIP, CPU_SS, CPU_ESP));
         VERBOSE(("JMPfar_pm: selector = 0x%04x, new_ip = 0x%08x", selector, new_ip));          VERBOSE(("JMPfar_pm: selector = 0x%04x, new_ip = 0x%08x", selector, new_ip));
   
         /*  
          * IF effective address in the CS, DS, ES, FS, GS, or SS segment is illegal  
          *     OR segment selector in target operand null  
          *     THEN #GP(0);  
          * FI;  
          */  
         /* XXX */  
   
         rv = parse_selector(&jmp_sel, selector);          rv = parse_selector(&jmp_sel, selector);
         if (rv < 0) {          if (rv < 0) {
                   VERBOSE(("JMPfar_pm: parse_selector (selector = %04x, rv = %d)", selector, rv));
                 EXCEPTION(GP_EXCEPTION, jmp_sel.idx);                  EXCEPTION(GP_EXCEPTION, jmp_sel.idx);
         }          }
   
         if (jmp_sel.desc.s) {          if (jmp_sel.desc.s) {
                 /* code segment descriptor */                  VERBOSE(("JMPfar_pm: code or data segment descriptor"));
   
                   /* check segment type */
                 if (!jmp_sel.desc.u.seg.c) {                  if (!jmp_sel.desc.u.seg.c) {
                         /* data segment */                          /* data segment */
                           VERBOSE(("JMPfar_pm: data segment"));
                         EXCEPTION(GP_EXCEPTION, jmp_sel.idx);                          EXCEPTION(GP_EXCEPTION, jmp_sel.idx);
                 }                  }
   
                 /* check privilege level */                  /* code segment descriptor */
                 if (!jmp_sel.desc.u.seg.ec) {                  JMPfar_pm_code_segment(&jmp_sel, new_ip);
                         VERBOSE(("NONCONFORMING-CODE-SEGMENT"));          } else {
                         /* 下巻 p.119 4.8.1.1. */                  /* system descriptor */
                         if ((jmp_sel.rpl > CPU_STAT_CPL)                  VERBOSE(("JMPfar_pm: system descriptor"));
                          || (jmp_sel.desc.dpl != CPU_STAT_CPL)) {  
                                 EXCEPTION(GP_EXCEPTION, jmp_sel.idx);  
                         }  
                 } else {  
                         VERBOSE(("CONFORMING-CODE-SEGMENT"));  
                         /* 下巻 p.120 4.8.1.2. */  
                         if (jmp_sel.desc.dpl > CPU_STAT_CPL) {  
                                 EXCEPTION(GP_EXCEPTION, jmp_sel.idx);  
                         }  
                 }  
   
                 /* not present */                  switch (jmp_sel.desc.type) {
                 if (selector_is_not_present(&jmp_sel)) {                  case CPU_SYSDESC_TYPE_CALL_16:
                         EXCEPTION(NP_EXCEPTION, jmp_sel.idx);                  case CPU_SYSDESC_TYPE_CALL_32:
                 }                          JMPfar_pm_call_gate(&jmp_sel);
                           break;
   
                 if (!CPU_INST_OP32) {                  case CPU_SYSDESC_TYPE_TASK:
                         new_ip &= 0xffff;                          JMPfar_pm_task_gate(&jmp_sel);
                 }                          break;
   
                 /* out of range */                  case CPU_SYSDESC_TYPE_TSS_16:
                 if (new_ip > jmp_sel.desc.u.seg.limit) {                  case CPU_SYSDESC_TYPE_TSS_32:
                         EXCEPTION(GP_EXCEPTION, 0);                          JMPfar_pm_tss(&jmp_sel);
                           break;
   
                   case CPU_SYSDESC_TYPE_TSS_BUSY_16:
                   case CPU_SYSDESC_TYPE_TSS_BUSY_32:
                           VERBOSE(("JMPfar_pm: task is busy"));
                           /*FALLTHROUGH*/
                   default:
                           VERBOSE(("JMPfar_pm: invalid descriptor type (type = %d)", jmp_sel.desc.type));
                           EXCEPTION(GP_EXCEPTION, jmp_sel.idx);
                           break;
                 }                  }
           }
           VERBOSE(("JMPfar_pm: new EIP = %04x:%08x, ESP = %04x:%08x", CPU_CS, CPU_EIP, CPU_SS, CPU_ESP));
   }
   
                 load_cs(jmp_sel.selector, &jmp_sel.desc, CPU_STAT_CPL);  /*---
                 SET_EIP(new_ip);   * JMPfar: code segment
    */
   static void
   JMPfar_pm_code_segment(selector_t *code_sel, DWORD new_ip)
   {
   
           /* check privilege level */
           if (!code_sel->desc.u.seg.ec) {
                   VERBOSE(("JMPfar_pm: NON-CONFORMING-CODE-SEGMENT"));
                   /* 下巻 p.119 4.8.1.1. */
                   if (code_sel->rpl > CPU_STAT_CPL) {
                           VERBOSE(("JMPfar_pm: RPL(%d) > CPL(%d)", code_sel->rpl, CPU_STAT_CPL));
                           EXCEPTION(GP_EXCEPTION, code_sel->idx);
                   }
                   if (code_sel->desc.dpl != CPU_STAT_CPL) {
                           VERBOSE(("JMPfar_pm: DPL(%d) != CPL(%d)", code_sel->desc.dpl, CPU_STAT_CPL));
                           EXCEPTION(GP_EXCEPTION, code_sel->idx);
                   }
         } else {          } else {
                 /* system descriptor */                  VERBOSE(("JMPfar_pm: CONFORMING-CODE-SEGMENT"));
                 switch (jmp_sel.desc.type) {                  /* 下巻 p.120 4.8.1.2. */
                 case CPU_SYSDESC_TYPE_CALL_16:                  if (code_sel->desc.dpl > CPU_STAT_CPL) {
                 case CPU_SYSDESC_TYPE_CALL_32:                          VERBOSE(("JMPfar_pm: DPL(%d) > CPL(%d)", code_sel->desc.dpl, CPU_STAT_CPL));
                         VERBOSE(("CALL-GATE"));                          EXCEPTION(GP_EXCEPTION, code_sel->idx);
                   }
           }
   
                         /* check privilege level */          /* not present */
                         if ((jmp_sel.desc.dpl < CPU_STAT_CPL)          if (selector_is_not_present(code_sel)) {
                          || (jmp_sel.desc.dpl < jmp_sel.rpl)) {                  VERBOSE(("JMPfar_pm: selector is not present"));
                                 EXCEPTION(GP_EXCEPTION, jmp_sel.idx);                  EXCEPTION(NP_EXCEPTION, code_sel->idx);
                         }          }
   
                         /* not present */          /* out of range */
                         if (selector_is_not_present(&jmp_sel)) {          if (new_ip > code_sel->desc.u.seg.limit) {
                                 EXCEPTION(NP_EXCEPTION, jmp_sel.idx);                  VERBOSE(("JMPfar_pm: new_ip is out of range. new_ip = %08x, limit = %08x", new_ip, code_sel->desc.u.seg.limit));
                         }                  EXCEPTION(GP_EXCEPTION, 0);
           }
   
                         /* parse call gate selector */          load_cs(code_sel->selector, &code_sel->desc, CPU_STAT_CPL);
                         rv = parse_selector(&sel2, jmp_sel.desc.u.gate.selector);          SET_EIP(new_ip);
                         if (rv < 0) {  }
                                 EXCEPTION(GP_EXCEPTION, sel2.idx);  
                         }  
   
                         /* check code segment descriptor */  /*---
                         if (!sel2.desc.s || !sel2.desc.u.seg.c) {   * JMPfar: call gate
                                 EXCEPTION(GP_EXCEPTION, sel2.idx);   */
                         }  static void
   JMPfar_pm_call_gate(selector_t *callgate_sel)
   {
           selector_t cs_sel;
           int rv;
   
                         /* check privilege level */          VERBOSE(("JMPfar_pm: CALL-GATE"));
                         if (!sel2.desc.u.seg.ec) {  
                                 /* 下巻 p.119 4.8.1.1. */  
                                 if ((sel2.rpl > CPU_STAT_CPL)  
                                  || (sel2.desc.dpl != CPU_STAT_CPL)) {  
                                         EXCEPTION(GP_EXCEPTION, sel2.idx);  
                                 }  
                         } else {  
                                 /* 下巻 p.120 4.8.1.2. */  
                                 if (sel2.desc.dpl > CPU_STAT_CPL) {  
                                         EXCEPTION(GP_EXCEPTION, sel2.idx);  
                                 }  
                         }  
   
                         /* not present */          /* check privilege level */
                         if (selector_is_not_present(&sel2)) {          if (callgate_sel->desc.dpl < CPU_STAT_CPL) {
                                 EXCEPTION(NP_EXCEPTION, sel2.idx);                  VERBOSE(("JMPfar_pm: DPL(%d) < CPL(%d)", callgate_sel->desc.dpl, CPU_STAT_CPL));
                         }                  EXCEPTION(GP_EXCEPTION, callgate_sel->idx);
           }
           if (callgate_sel->desc.dpl < callgate_sel->rpl) {
                   VERBOSE(("JMPfar_pm: DPL(%d) < RPL(%d)",  callgate_sel->desc.dpl, callgate_sel->rpl));
                   EXCEPTION(GP_EXCEPTION, callgate_sel->idx);
           }
   
                         new_ip = jmp_sel.desc.u.gate.offset;          /* not present */
                         if (jmp_sel.desc.type == CPU_SYSDESC_TYPE_CALL_16) {          if (selector_is_not_present(callgate_sel)) {
                                 new_ip &= 0xffff;                  VERBOSE(("JMPfar_pm: selector is not present"));
                         }                  EXCEPTION(NP_EXCEPTION, callgate_sel->idx);
           }
   
                         /* out of range */          /* parse code segment selector */
                         if (new_ip > sel2.desc.u.seg.limit) {          rv = parse_selector(&cs_sel, callgate_sel->desc.u.gate.selector);
                                 EXCEPTION(GP_EXCEPTION, 0);          if (rv < 0) {
                         }                  VERBOSE(("JMPfar_pm: parse_selector (selector = %04x, rv = %d)", callgate_sel->desc.u.gate.selector, rv));
                   EXCEPTION(GP_EXCEPTION, cs_sel.idx);
           }
   
                         load_cs(sel2.selector, &sel2.desc, CPU_STAT_CPL);          /* check segment type */
                         SET_EIP(new_ip);          if (!cs_sel.desc.s) {
                         break;                  VERBOSE(("JMPfar_pm: code segment is system segment"));
                   EXCEPTION(GP_EXCEPTION, cs_sel.idx);
           }
           if (!cs_sel.desc.u.seg.c) {
                   VERBOSE(("JMPfar_pm: code segment is data segment"));
                   EXCEPTION(GP_EXCEPTION, cs_sel.idx);
           }
   
                 /*          /* check privilege level */
                  * 中巻 p.373 JMP 命令          if (!cs_sel.desc.u.seg.ec) {
                  *                  /* 下巻 p.119 4.8.1.1. */
                  * JMP 命令でタスク・スイッチを実行するときは EFLAGS レジスタに                  if (cs_sel.rpl > CPU_STAT_CPL) {
                  * ネストされたタスク・フラグ (NT) がセットされず、新しい TSS の                          VERBOSE(("JMPfar_pm: RPL(%d) > CPL(%d)", cs_sel.rpl, CPU_STAT_CPL));
                  * 以前のタスク・リンク・フィールドに前のタスクの TSS セレクタが                          EXCEPTION(GP_EXCEPTION, cs_sel.idx);
                  * ロードされないので注意されたい。したがって、前のタスクへの                  }
                  * リターンは IRET 命令の実行では実現できない。JMP 命令で                  if (cs_sel.desc.dpl != CPU_STAT_CPL) {
                  * タスク・スイッチを実行するのは、その点で CALL 命令と異なる。                          VERBOSE(("JMPfar_pm: DPL(%d) != CPL(%d)", cs_sel.desc.dpl, CPU_STAT_CPL));
                  * すなわち、CALL 命令は NT フラグをセットし、以前の                          EXCEPTION(GP_EXCEPTION, cs_sel.idx);
                  * タスク・リンク情報をセーブするので、IRET 命令でのコール元                  }
                  * タスクへのリターンが可能になる。          } else {
                  */                  /* 下巻 p.120 4.8.1.2. */
                 case CPU_SYSDESC_TYPE_TASK:                  if (cs_sel.desc.dpl > CPU_STAT_CPL) {
                         VERBOSE(("TASK-GATE"));                          VERBOSE(("JMPfar_pm: DPL(%d) > CPL(%d)", cs_sel.desc.dpl, CPU_STAT_CPL));
                           EXCEPTION(GP_EXCEPTION, cs_sel.idx);
                   }
           }
   
                         /* check privilege level */          /* not present */
                         if ((jmp_sel.desc.dpl < CPU_STAT_CPL)          if (selector_is_not_present(&cs_sel)) {
                          || (jmp_sel.desc.dpl < jmp_sel.rpl)) {                  VERBOSE(("JMPfar_pm: selector is not present"));
                                 EXCEPTION(GP_EXCEPTION, jmp_sel.idx);                  EXCEPTION(NP_EXCEPTION, cs_sel.idx);
                         }          }
   
                         /* not present */          /* out of range */
                         if (selector_is_not_present(&jmp_sel)) {          if (callgate_sel->desc.u.gate.offset > cs_sel.desc.u.seg.limit) {
                                 EXCEPTION(NP_EXCEPTION, jmp_sel.idx);                  VERBOSE(("JMPfar_pm: new_ip is out of range. new_ip = %08x, limit = %08x", callgate_sel->desc.u.gate.offset, cs_sel.desc.u.seg.limit));
                         }                  EXCEPTION(GP_EXCEPTION, 0);
           }
   
                         /* parse call tss selector */          load_cs(cs_sel.selector, &cs_sel.desc, CPU_STAT_CPL);
                         rv = parse_selector(&sel2, jmp_sel.desc.u.gate.selector);          SET_EIP(callgate_sel->desc.u.gate.offset);
                         if (rv < 0 || sel2.ldt) {  }
                                 EXCEPTION(GP_EXCEPTION, sel2.idx);  
                         }  
   
                         /* check descriptor type */  /*---
                         switch (sel2.desc.type) {   * JMPfar: task gate
                         case CPU_SYSDESC_TYPE_TSS_16:   */
                         case CPU_SYSDESC_TYPE_TSS_32:  static void
                                 break;  JMPfar_pm_task_gate(selector_t *taskgate_sel)
   {
                         default:          selector_t tss_sel;
                                 EXCEPTION(GP_EXCEPTION, sel2.idx);          int rv;
                                 break;  
                         }  
   
                         /* not present */          VERBOSE(("JMPfar_pm: TASK-GATE"));
                         if (selector_is_not_present(&sel2)) {  
                                 EXCEPTION(NP_EXCEPTION, sel2.idx);  
                         }  
   
                         task_switch(&sel2, TASK_SWITCH_JMP);          /*
            * 中巻 p.373 JMP 命令
            *
            * JMP 命令でタスク・スイッチを実行するときは EFLAGS レジスタに
            * ネストされたタスク・フラグ (NT) がセットされず、新しい TSS の
            * 以前のタスク・リンク・フィールドに前のタスクの TSS セレクタが
            * ロードされないので注意されたい。したがって、前のタスクへの
            * リターンは IRET 命令の実行では実現できない。JMP 命令で
            * タスク・スイッチを実行するのは、その点で CALL 命令と異なる。
            * すなわち、CALL 命令は NT フラグをセットし、以前の
            * タスク・リンク情報をセーブするので、IRET 命令でのコール元
            * タスクへのリターンが可能になる。
            */
   
                         /* out of range */          /* check privilege level */
                         if (CPU_EIP > CPU_STAT_CS_LIMIT) {          if (taskgate_sel->desc.dpl < CPU_STAT_CPL) {
                                 EXCEPTION(GP_EXCEPTION, 0);                  VERBOSE(("JMPfar_pm: DPL(%d) < CPL(%d)", taskgate_sel->desc.dpl, CPU_STAT_CPL));
                         }                  EXCEPTION(GP_EXCEPTION, taskgate_sel->idx);
                         break;          }
           if (taskgate_sel->desc.dpl < taskgate_sel->rpl) {
                   VERBOSE(("JMPfar_pm: DPL(%d) < RPL(%d)", taskgate_sel->desc.dpl, taskgate_sel->rpl));
                   EXCEPTION(GP_EXCEPTION, taskgate_sel->idx);
           }
   
                 case CPU_SYSDESC_TYPE_TSS_16:          /* not present */
                 case CPU_SYSDESC_TYPE_TSS_32:          if (selector_is_not_present(taskgate_sel)) {
                         VERBOSE(("TASK-STATE-SEGMENT"));                  VERBOSE(("JMPfar_pm: selector is not present"));
                   EXCEPTION(NP_EXCEPTION, taskgate_sel->idx);
           }
   
                         /* check privilege level */          /* parse tss selector */
                         if ((jmp_sel.desc.dpl < CPU_STAT_CPL)          rv = parse_selector(&tss_sel, taskgate_sel->desc.u.gate.selector);
                          || (jmp_sel.desc.dpl < jmp_sel.rpl)) {          if (rv < 0 || tss_sel.ldt) {
                                 EXCEPTION(TS_EXCEPTION, jmp_sel.idx);                  VERBOSE(("JMPfar_pm: parse_selector (selector = %04x, rv = %d, %cDT)", taskgate_sel->desc.u.gate.selector, rv, tss_sel.ldt ? 'L' : 'G'));
                         }                  EXCEPTION(GP_EXCEPTION, tss_sel.idx);
           }
   
                         /* not present */          /* check descriptor type */
                         if (selector_is_not_present(&jmp_sel)) {          switch (tss_sel.desc.type) {
                                 EXCEPTION(NP_EXCEPTION, jmp_sel.idx);          case CPU_SYSDESC_TYPE_TSS_16:
                         }          case CPU_SYSDESC_TYPE_TSS_32:
                   break;
   
           case CPU_SYSDESC_TYPE_TSS_BUSY_16:
           case CPU_SYSDESC_TYPE_TSS_BUSY_32:
                   VERBOSE(("JMPfar_pm: task is busy"));
                   /*FALLTHROUGH*/
           default:
                   VERBOSE(("JMPfar_pm: invalid descriptor type (type = %d)", tss_sel.desc.type));
                   EXCEPTION(GP_EXCEPTION, tss_sel.idx);
                   break;
           }
   
                         task_switch(&jmp_sel, TASK_SWITCH_JMP);          /* not present */
           if (selector_is_not_present(&tss_sel)) {
                   VERBOSE(("JMPfar_pm: selector is not present"));
                   EXCEPTION(NP_EXCEPTION, tss_sel.idx);
           }
   
                         /* out of range */          task_switch(&tss_sel, TASK_SWITCH_JMP);
                         if (CPU_EIP > CPU_STAT_CS_LIMIT) {  }
                                 EXCEPTION(GP_EXCEPTION, 0);  
                         }  
                         break;  
   
                 case CPU_SYSDESC_TYPE_TSS_BUSY_16:  /*---
                 case CPU_SYSDESC_TYPE_TSS_BUSY_32:   * JMPfar: TSS
                         VERBOSE(("JMPfar_pm: task is busy"));   */
                         /*FALLTHROUGH*/  static void
                 default:  JMPfar_pm_tss(selector_t *tss_sel)
                         EXCEPTION(GP_EXCEPTION, jmp_sel.idx);  {
                         break;  
                 }          VERBOSE(("JMPfar_pm: TASK-STATE-SEGMENT"));
   
           /* check privilege level */
           if (tss_sel->desc.dpl < CPU_STAT_CPL) {
                   VERBOSE(("JMPfar_pm: DPL(%d) < CPL(%d)", tss_sel->desc.dpl, CPU_STAT_CPL));
                   EXCEPTION(GP_EXCEPTION, tss_sel->idx);
           }
           if (tss_sel->desc.dpl < tss_sel->rpl) {
                   VERBOSE(("JMPfar_pm: DPL(%d) < RPL(%d)", tss_sel->desc.dpl, tss_sel->rpl));
                   EXCEPTION(GP_EXCEPTION, tss_sel->idx);
           }
   
           /* not present */
           if (selector_is_not_present(tss_sel)) {
                   VERBOSE(("JMPfar_pm: selector is not present"));
                   EXCEPTION(NP_EXCEPTION, tss_sel->idx);
         }          }
   
           task_switch(tss_sel, TASK_SWITCH_JMP);
 }  }
   
   
   /*------------------------------------------------------------------------------
    * CALLfar_pm
    */
   static void CALLfar_pm_code_segment(selector_t *call_sel, DWORD new_ip);
   static void CALLfar_pm_call_gate(selector_t *call_sel);
   static void CALLfar_pm_task_gate(selector_t *call_sel);
   static void CALLfar_pm_tss(selector_t *call_sel);
   
 /*  /*
  * 4.3.6. 特権レベル間のコール操作   * 4.3.6. 特権レベル間のコール操作
  *   *
  * 1. アクセス権のチェック(特権チェック)を実行する。   * 1. アクセス権のチェック(特権チェック)を実行する。
  * 2. SS, ESP, CS, EIP の各レジスタの現在地を一時的に内部にセーブする。   * 2. SS, ESP, CS, EIP の各レジスタの現在値を一時的に内部にセーブする。
  * 3. TSS レジスタに格納されている新しいスタック(すなわち、現在コールされている   * 3. TSS レジスタに格納されている新しいスタック(すなわち、現在コールされている
  *    特権レベル用のスタック)のセグメントレジスタとスタックポインタを   *    特権レベル用のスタック)のセグメントレジスタとスタックポインタを
  *    SS レジスタと ESP レジスタにロードし、新しいスタックに切り替える。   *    SS レジスタと ESP レジスタにロードし、新しいスタックに切り替える。
  * 4. コール元プロシージャのスタックに対して一時的にセーブしておいた SS 値と   * 4. コール元プロシージャのスタックに対して一時的にセーブしておいた SS と
  *    ESP 値を、この新しいスタックにプッシュする。   *    ESP を、この新しいスタックにプッシュする。
  * 5. コール元プロシージャのスタックからパラメータをコピーする。新しいスタック   * 5. コール元プロシージャのスタックからパラメータをコピーする。新しいスタック
  *    にコピーされるパラメータの数は、コール・ゲート・ディスクリプタ内の値で   *    にコピーされるパラメータの数は、コール・ゲート・ディスクリプタ内の値で
  *    決まる。   *    決まる。
  * 6. コール元プロシージャに対して一時的にセーブしておいた CS 値と EIP 値を、   * 6. コール元プロシージャに対して一時的にセーブしておいた CS と EIP を、
  *    新しいスタックにプッシュする。   *    新しいスタックにプッシュする。
  * 7. 新しいコード・セグメントのセグメント・セレクタと新しい命令ポインタを、   * 7. 新しいコード・セグメントのセグメント・セレクタと新しい命令ポインタを、
  *    コール・ゲートから CS レジスタと EIP レジスタにそれぞれロードする。   *    コール・ゲートから CS レジスタと EIP レジスタにそれぞれロードする。
Line 271  void Line 357  void
 CALLfar_pm(WORD selector, DWORD new_ip)  CALLfar_pm(WORD selector, DWORD new_ip)
 {  {
         selector_t call_sel;          selector_t call_sel;
         selector_t sel2;  
         int rv;          int rv;
   
           VERBOSE(("CALLfar_pm: old EIP = %04x:%08x, ESP = %04x:%08x", CPU_CS, CPU_PREV_EIP, CPU_SS, CPU_ESP));
         VERBOSE(("CALLfar_pm: selector = 0x%04x, new_ip = 0x%08x", selector, new_ip));          VERBOSE(("CALLfar_pm: selector = 0x%04x, new_ip = 0x%08x", selector, new_ip));
   
         rv = parse_selector(&call_sel, selector);          rv = parse_selector(&call_sel, selector);
         if (rv < 0) {          if (rv < 0) {
                   VERBOSE(("CALLfar_pm: parse_selector (selector = %04x, rv = %d)", selector, rv));
                 EXCEPTION(GP_EXCEPTION, call_sel.idx);                  EXCEPTION(GP_EXCEPTION, call_sel.idx);
         }          }
   
         if (call_sel.desc.s) {          if (call_sel.desc.s) {
                 /* code segment descriptor */                  /* code or data segment descriptor */
                   VERBOSE(("CALLfar_pm: code or data segment descriptor"));
   
                 if (!call_sel.desc.u.seg.c) {                  if (!call_sel.desc.u.seg.c) {
                         /* data segment */                          /* data segment */
                           VERBOSE(("CALLfar_pm: data segment"));
                         EXCEPTION(GP_EXCEPTION, call_sel.idx);                          EXCEPTION(GP_EXCEPTION, call_sel.idx);
                 }                  }
   
                 /* check privilege level */                  /* code segment descriptor */
                 if (!call_sel.desc.u.seg.ec) {                  CALLfar_pm_code_segment(&call_sel, new_ip);
                         VERBOSE(("NONCONFORMING-CODE-SEGMENT"));          } else {
                   /* system descriptor */
                   VERBOSE(("CALLfar_pm: system descriptor"));
   
                         /* 下巻 p.119 4.8.1.1. */                  switch (call_sel.desc.type) {
                         if ((call_sel.rpl > CPU_STAT_CPL)                  case CPU_SYSDESC_TYPE_CALL_16:
                          || (call_sel.desc.dpl != CPU_STAT_CPL)) {                  case CPU_SYSDESC_TYPE_CALL_32:
                                 EXCEPTION(GP_EXCEPTION, call_sel.idx);                          CALLfar_pm_call_gate(&call_sel);
                         }                          break;
                 } else {  
                         VERBOSE(("CONFORMING-CODE-SEGMENT"));  
   
                         /* 下巻 p.120 4.8.1.2. */                  case CPU_SYSDESC_TYPE_TASK:
                         if (call_sel.desc.dpl > CPU_STAT_CPL) {                          CALLfar_pm_task_gate(&call_sel);
                                 EXCEPTION(GP_EXCEPTION, call_sel.idx);                          break;
                         }  
                   case CPU_SYSDESC_TYPE_TSS_16:
                   case CPU_SYSDESC_TYPE_TSS_32:
                           CALLfar_pm_tss(&call_sel);
                           break;
   
                   case CPU_SYSDESC_TYPE_TSS_BUSY_16:
                   case CPU_SYSDESC_TYPE_TSS_BUSY_32:
                           VERBOSE(("CALLfar_pm: task is busy"));
                           /*FALLTHROUGH*/
                   default:
                           VERBOSE(("CALLfar_pm: invalid descriptor type (type = %d)", call_sel.desc.type));
                           EXCEPTION(GP_EXCEPTION, call_sel.idx);
                           break;
                 }                  }
           }
   
                 /* not present */          VERBOSE(("CALLfar_pm: new EIP = %04x:%08x, new ESP = %04x:%08x", CPU_CS, CPU_EIP, CPU_SS, CPU_ESP));
                 if (selector_is_not_present(&call_sel)) {  }
                         EXCEPTION(NP_EXCEPTION, call_sel.idx);  
   /*---
    * CALLfar_pm: code segment
    */
   static void
   CALLfar_pm_code_segment(selector_t *call_sel, DWORD new_ip)
   {
           DWORD sp;
   
           /* check privilege level */
           if (!call_sel->desc.u.seg.ec) {
                   VERBOSE(("CALLfar_pm: NON-CONFORMING-CODE-SEGMENT"));
                   /* 下巻 p.119 4.8.1.1. */
                   if (call_sel->rpl > CPU_STAT_CPL) {
                           VERBOSE(("CALLfar_pm: RPL(%d) > CPL(%d)", call_sel->rpl, CPU_STAT_CPL));
                           EXCEPTION(GP_EXCEPTION, call_sel->idx);
                   }
                   if (call_sel->desc.dpl != CPU_STAT_CPL) {
                           VERBOSE(("CALLfar_pm: DPL(%d) != CPL(%d)", call_sel->desc.dpl, CPU_STAT_CPL));
                           EXCEPTION(GP_EXCEPTION, call_sel->idx);
                   }
           } else {
                   VERBOSE(("CALLfar_pm: CONFORMING-CODE-SEGMENT"));
                   /* 下巻 p.120 4.8.1.2. */
                   if (call_sel->desc.dpl > CPU_STAT_CPL) {
                           VERBOSE(("CALLfar_pm: DPL(%d) > CPL(%d)", call_sel->desc.dpl, CPU_STAT_CPL));
                           EXCEPTION(GP_EXCEPTION, call_sel->idx);
                 }                  }
           }
   
                 if (CPU_INST_OP32) {          /* not present */
                         CHECK_STACK_PUSH(&CPU_STAT_SREG(CPU_SS_INDEX), CPU_ESP, 8);          if (selector_is_not_present(call_sel)) {
                         /* out of range */                  VERBOSE(("CALLfar_pm: selector is not present"));
                         if (new_ip > call_sel.desc.u.seg.limit) {                  EXCEPTION(NP_EXCEPTION, call_sel->idx);
                                 EXCEPTION(GP_EXCEPTION, 0);          }
                         }  
   
                         PUSH0_32(CPU_CS);          if (CPU_STAT_SS32) {
                         PUSH0_32(CPU_EIP);                  sp = CPU_ESP;
                 } else {          } else {
                         CHECK_STACK_PUSH(&CPU_STAT_SREG(CPU_SS_INDEX), CPU_ESP, 4);                  sp = CPU_SP;
                         /* out of range */          }
                         if (new_ip > call_sel.desc.u.seg.limit) {          if (CPU_INST_OP32) {
                                 EXCEPTION(GP_EXCEPTION, 0);                  CHECK_STACK_PUSH(&CPU_STAT_SREG(CPU_SS_INDEX), sp, 8);
                         }  
   
                         PUSH0_16(CPU_CS);                  /* out of range */
                         PUSH0_16(CPU_IP);                  if (new_ip > call_sel->desc.u.seg.limit) {
                         new_ip &= 0xffff;                          VERBOSE(("CALLfar_pm: new_ip is out of range. new_ip = %08x, limit = %08x", new_ip, call_sel->desc.u.seg.limit));
                           EXCEPTION(GP_EXCEPTION, 0);
                 }                  }
                 load_cs(call_sel.selector, &call_sel.desc, CPU_STAT_CPL);  
                   PUSH0_32(CPU_CS);
                   PUSH0_32(CPU_EIP);
           } else {
                   CHECK_STACK_PUSH(&CPU_STAT_SREG(CPU_SS_INDEX), sp, 4);
   
                   /* out of range */
                   if (new_ip > call_sel->desc.u.seg.limit) {
                           VERBOSE(("CALLfar_pm: new_ip is out of range. new_ip = %08x, limit = %08x", new_ip, call_sel->desc.u.seg.limit));
                           EXCEPTION(GP_EXCEPTION, 0);
                   }
   
                   PUSH0_16(CPU_CS);
                   PUSH0_16(CPU_IP);
           }
   
           load_cs(call_sel->selector, &call_sel->desc, CPU_STAT_CPL);
           SET_EIP(new_ip);
   }
   
   /*---
    * CALLfar_pm: call gate
    */
   static void CALLfar_pm_call_gate_same_privilege(selector_t *call_sel, selector_t *cs_sel);
   static void CALLfar_pm_call_gate_more_privilege(selector_t *call_sel, selector_t *cs_sel);
   
   static void
   CALLfar_pm_call_gate(selector_t *callgate_sel)
   {
           selector_t cs_sel;
           int rv;
   
           VERBOSE(("CALLfar_pm: CALL-GATE"));
   
           /* check privilege level */
           if (callgate_sel->desc.dpl < CPU_STAT_CPL) {
                   VERBOSE(("CALLfar_pm: DPL(%d) < CPL(%d)", callgate_sel->desc.dpl, CPU_STAT_CPL));
                   EXCEPTION(GP_EXCEPTION, callgate_sel->idx);
           }
           if (callgate_sel->desc.dpl < callgate_sel->rpl) {
                   VERBOSE(("CALLfar_pm: DPL(%d) < CPL(%d)", callgate_sel->desc.dpl, callgate_sel->rpl));
                   EXCEPTION(GP_EXCEPTION, callgate_sel->idx);
           }
   
           /* not present */
           if (selector_is_not_present(callgate_sel)) {
                   VERBOSE(("CALLfar_pm: selector is not present"));
                   EXCEPTION(NP_EXCEPTION, callgate_sel->idx);
           }
   
           /* parse code segment descriptor */
           rv = parse_selector(&cs_sel, callgate_sel->desc.u.gate.selector);
           if (rv < 0) {
                   VERBOSE(("CALLfar_pm: parse_selector (selector = %04x, rv = %d)", callgate_sel->desc.u.gate.selector, rv));
                   EXCEPTION(GP_EXCEPTION, cs_sel.idx);
           }
   
           /* check segment type */
           if (!cs_sel.desc.s) {
                   VERBOSE(("CALLfar_pm: code segment is system segment"));
                   EXCEPTION(GP_EXCEPTION, cs_sel.idx);
           }
           if (!cs_sel.desc.u.seg.c) {
                   VERBOSE(("CALLfar_pm: code segment is data segment"));
                   EXCEPTION(GP_EXCEPTION, cs_sel.idx);
           }
   
           /* check privilege level */
           if (cs_sel.desc.dpl > CPU_STAT_CPL) {
                   VERBOSE(("CALLfar_pm: DPL(%d) > CPL(%d)", cs_sel.desc.dpl, CPU_STAT_CPL));
                   EXCEPTION(GP_EXCEPTION, cs_sel.idx);
           }
   
           /* not present */
           if (selector_is_not_present(&cs_sel)) {
                   VERBOSE(("CALLfar_pm: selector is not present"));
                   EXCEPTION(NP_EXCEPTION, cs_sel.idx);
           }
   
           /* out of range */
           if (callgate_sel->desc.u.gate.offset > cs_sel.desc.u.seg.limit) {
                   VERBOSE(("CALLfar_pm: new_ip is out of range. new_ip = %08x, limit = %08x", callgate_sel->desc.u.gate.offset, cs_sel.desc.u.seg.limit));
                   EXCEPTION(GP_EXCEPTION, 0);
           }
   
           if (!cs_sel.desc.u.seg.ec && (cs_sel.desc.dpl < CPU_STAT_CPL)) {
                   CALLfar_pm_call_gate_more_privilege(callgate_sel, &cs_sel);
           } else {
                   CALLfar_pm_call_gate_same_privilege(callgate_sel, &cs_sel);
           }
   }
   
   /*---
    * CALLfar_pm: call gate (SAME-PRIVILEGE)
    */
   static void
   CALLfar_pm_call_gate_same_privilege(selector_t *callgate_sel, selector_t *cs_sel)
   {
           DWORD sp;
           DWORD new_ip;
   
           VERBOSE(("CALLfar_pm: SAME-PRIVILEGE"));
   
           if (CPU_STAT_SS32) {
                   sp = CPU_ESP;
           } else {
                   sp = CPU_SP;
           }
           new_ip = callgate_sel->desc.u.gate.offset;
   
           if (callgate_sel->desc.type == CPU_SYSDESC_TYPE_CALL_32) {
                   CHECK_STACK_PUSH(&CPU_STAT_SREG(CPU_SS_INDEX), sp, 8);
   
                   PUSH0_32(CPU_CS);
                   PUSH0_32(CPU_EIP);
   
                   load_cs(cs_sel->selector, &cs_sel->desc, CPU_STAT_CPL);
                 SET_EIP(new_ip);                  SET_EIP(new_ip);
         } else {          } else {
                 DWORD temp_eip, temp_esp;                  CHECK_STACK_PUSH(&CPU_STAT_SREG(CPU_SS_INDEX), sp, 4);
                 WORD temp_cs, temp_ss;  
   
                 /* system descriptor */                  PUSH0_16(CPU_CS);
                 switch (call_sel.desc.type) {                  PUSH0_16(CPU_IP);
                 case CPU_SYSDESC_TYPE_CALL_16:  
                 case CPU_SYSDESC_TYPE_CALL_32:  
                         VERBOSE(("CALL-GATE"));  
   
                         /* check privilege level */                  load_cs(cs_sel->selector, &cs_sel->desc, CPU_STAT_CPL);
                         if ((call_sel.desc.dpl < CPU_STAT_CPL)                  SET_EIP(new_ip);
                          || (call_sel.desc.dpl < call_sel.rpl)) {          }
                                 EXCEPTION(GP_EXCEPTION, call_sel.idx);  }
                         }  
   
                         /* not present */  /*---
                         if (selector_is_not_present(&call_sel)) {   * CALLfar_pm: call gate (MORE-PRIVILEGE)
                                 EXCEPTION(NP_EXCEPTION, call_sel.idx);   */
                         }  static void
   CALLfar_pm_call_gate_more_privilege(selector_t *callgate_sel, selector_t *cs_sel)
   {
           DWORD param[32];        /* copy param */
           selector_t ss_sel;
           DWORD sp;
           DWORD old_eip, old_esp;
           DWORD tss_esp;
           WORD old_cs, old_ss;
           WORD tss_ss;
           int param_count;
           int i;
           int rv;
   
                         /* parse code segment descriptor */          VERBOSE(("CALLfar_pm: MORE-PRIVILEGE"));
                         rv = parse_selector(&sel2, call_sel.desc.u.gate.selector);  
                         if (rv < 0) {  
                                 EXCEPTION(GP_EXCEPTION, sel2.idx);  
                         }  
   
                         /* check code segment & privilege level */          /* save register */
                         if (!sel2.desc.s          old_cs = CPU_CS;
                          || !sel2.desc.u.seg.c          old_ss = CPU_SS;
                          || sel2.desc.dpl > CPU_STAT_CPL) {          old_eip = CPU_EIP;
                                 EXCEPTION(GP_EXCEPTION, sel2.idx);          old_esp = CPU_ESP;
                         }  
   
                         /* not present */          if (CPU_STAT_SS32) {
                         if (selector_is_not_present(&sel2)) {                  sp = CPU_ESP;
                                 EXCEPTION(NP_EXCEPTION, sel2.idx);          } else {
                         }                  sp = CPU_SP;
           }
   
                         /* save register */          /* get stack pointer from TSS */
                         temp_cs = CPU_CS;          get_stack_from_tss(cs_sel->desc.dpl, &tss_ss, &tss_esp);
                         temp_ss = CPU_SS;  
                         temp_eip = CPU_EIP;  
                         temp_esp = CPU_ESP;  
                         if (sel2.desc.type == CPU_SYSDESC_TYPE_CALL_16) {  
                                 temp_eip &= 0xffff;  
                                 temp_esp &= 0xffff;  
                         }  
   
                         new_ip = call_sel.desc.u.gate.offset;          /* parse stack segment descriptor */
           rv = parse_selector(&ss_sel, tss_ss);
           if (rv < 0) {
                   VERBOSE(("CALLfar_pm: parse_selector (selector = %04x, rv = %d)", tss_ss, rv));
                   EXCEPTION(TS_EXCEPTION, ss_sel.idx);
           }
   
                         /* out of range */          /* check privilege level */
                         if (new_ip > sel2.desc.u.seg.limit) {          if (ss_sel.rpl != cs_sel->desc.dpl) {
                                 EXCEPTION(GP_EXCEPTION, 0);                  VERBOSE(("CALLfar_pm: RPL[SS](%d) != DPL[CS](%d)", ss_sel.rpl, cs_sel->desc.dpl));
                         }                  EXCEPTION(TS_EXCEPTION, ss_sel.idx);
           }
           if (ss_sel.desc.dpl != cs_sel->desc.dpl) {
                   VERBOSE(("CALLfar_pm: DPL[SS](%d) != DPL[CS](%d)", ss_sel.desc.dpl, cs_sel->desc.dpl));
                   EXCEPTION(TS_EXCEPTION, ss_sel.idx);
           }
   
                         if (!sel2.desc.u.seg.ec          /* stack segment must be writable data segment. */
                          && (sel2.desc.dpl < CPU_STAT_CPL)) {          if (!ss_sel.desc.s) {
                                 DWORD param[32];        // copy param                  VERBOSE(("CALLfar_pm: stack segment is system segment"));
                                 selector_t ss_sel;                  EXCEPTION(TS_EXCEPTION, ss_sel.idx);
                                 DWORD tss_esp;          }
                                 WORD tss_ss;          if (ss_sel.desc.u.seg.c) {
                                 BYTE i;                  VERBOSE(("CALLfar_pm: stack segment is code segment"));
                   EXCEPTION(TS_EXCEPTION, ss_sel.idx);
                                 VERBOSE(("MORE-PRIVILEGE"));          }
           if (!ss_sel.desc.u.seg.wr) {
                                 get_stack_from_tss(sel2.desc.dpl, &tss_ss, &tss_esp);                  VERBOSE(("CALLfar_pm: stack segment is read-only data segment"));
                   EXCEPTION(TS_EXCEPTION, ss_sel.idx);
                                 /* parse stack segment descriptor */          }
                                 rv = parse_selector(&ss_sel, tss_ss);  
                                 if (rv < 0) {          /* not present */
                                         EXCEPTION(TS_EXCEPTION, ss_sel.idx);          if (selector_is_not_present(&ss_sel)) {
                                 }                  VERBOSE(("CALLfar_pm: stack segment selector is not present"));
                   EXCEPTION(SS_EXCEPTION, ss_sel.idx);
           }
   
           param_count = callgate_sel->desc.u.gate.count;
           VERBOSE(("CALLfar_pm: param_count = %d", param_count));
   
           if (callgate_sel->desc.type == CPU_SYSDESC_TYPE_CALL_32) {
                   CHECK_STACK_PUSH(&ss_sel.desc, tss_esp, 16 + param_count * 4);
   
                   /* dump param */
                   for (i = 0; i < param_count; i++) {
                           param[i] = cpu_vmemoryread_d(CPU_SS_INDEX, sp + i * 4);
                           VERBOSE(("CALLfar_pm: get param[%d] = %08x", i, param[i]));
                   }
   
                                 /* check privilege level */                  load_ss(ss_sel.selector, &ss_sel.desc, ss_sel.desc.dpl);
                                 if ((ss_sel.rpl != sel2.desc.dpl)                  if (CPU_STAT_SS32) {
                                  || (ss_sel.desc.dpl != sel2.desc.dpl)                          CPU_ESP = tss_esp;
                                  || !ss_sel.desc.s                  } else {
                                  || !ss_sel.desc.u.seg.wr) {                          CPU_SP = (WORD)tss_esp;
                                         EXCEPTION(TS_EXCEPTION, ss_sel.idx);                  }
                                 }  
   
                                 /* not present */                  load_cs(cs_sel->selector, &cs_sel->desc, cs_sel->desc.dpl);
                                 if (selector_is_not_present(&ss_sel)) {                  SET_EIP(callgate_sel->desc.u.gate.offset);
                                         EXCEPTION(NP_EXCEPTION, ss_sel.idx);  
                                 }  
   
                                 if (call_sel.desc.type == CPU_SYSDESC_TYPE_CALL_32){                  PUSH0_32(old_ss);
                                         CHECK_STACK_PUSH(&ss_sel.desc, tss_esp, 16 + sel2.desc.u.gate.count * 4);                  PUSH0_32(old_esp);
   
                                         /* dump param */                  /* restore param */
                                         for (i = 0; i < sel2.desc.u.gate.count; i++) {                  for (i = param_count; i != 0; i--) {
                                                 param[i] = cpu_vmemoryread_d(CPU_SS_INDEX, CPU_ESP + i * 4);                          PUSH0_32(param[i - 1]);
                                         }                          VERBOSE(("CALLfar_pm: set param[%d] = %08x", i - 1, param[i - 1]));
                   }
                                         load_ss(tss_ss, &ss_sel.desc, ss_sel.desc.dpl);  
                                         CPU_ESP = tss_esp;  
                                         load_cs(sel2.selector, &sel2.desc, sel2.desc.dpl);  
                                         SET_EIP(new_ip);  
   
                                         PUSH0_32(temp_ss);  
                                         PUSH0_32(temp_esp);  
   
                                         /* restore param */  
                                         for (i = sel2.desc.u.gate.count; i != 0; i--) {  
                                                 PUSH0_32(param[i - 1]);  
                                         }  
   
                                         PUSH0_32(temp_cs);  
                                         PUSH0_32(temp_eip);  
                                 } else {  
                                         CHECK_STACK_PUSH(&ss_sel.desc, tss_esp, 8 + sel2.desc.u.gate.count * 2);  
   
                                         new_ip &= 0xffff;  
   
                                         /* dump param */  
                                         for (i = 0; i < sel2.desc.u.gate.count; i++) {  
                                                 param[i] = cpu_vmemoryread_w(CPU_SS_INDEX, CPU_ESP + i * 2);  
                                         }  
   
                                         load_ss(tss_ss, &ss_sel.desc, ss_sel.desc.dpl);  
                                         CPU_ESP = tss_esp & 0xffff;  
                                         load_cs(sel2.selector, &sel2.desc, sel2.desc.dpl);  
                                         SET_EIP(new_ip);  
   
                                         PUSH0_16(temp_ss);  
                                         PUSH0_16(temp_esp);  
   
                                         /* restore param */  
                                         for (i = sel2.desc.u.gate.count; i != 0; i--) {  
                                                 PUSH0_16(param[i - 1]);  
                                         }  
   
                                         PUSH0_16(temp_cs);                  PUSH0_32(old_cs);
                                         PUSH0_16(temp_eip);                  PUSH0_32(old_eip);
                                 }          } else {
                         } else {                  CHECK_STACK_PUSH(&ss_sel.desc, tss_esp, 8 + param_count * 2);
                                 VERBOSE(("SAME-PRIVILEGE"));  
   
                                 if (call_sel.desc.type == CPU_SYSDESC_TYPE_CALL_32){                  /* dump param */
                                         CHECK_STACK_PUSH(&CPU_STAT_SREG(CPU_SS_INDEX), CPU_ESP, 8);                  for (i = 0; i < param_count; i++) {
                           param[i] = cpu_vmemoryread_w(CPU_SS_INDEX, sp + i * 2);
                           VERBOSE(("CALLfar_pm: get param[%d] = %04x", i, param[i]));
                   }
   
                                         load_cs(sel2.selector, &sel2.desc, CPU_STAT_CPL);                  load_ss(ss_sel.selector, &ss_sel.desc, ss_sel.desc.dpl);
                                         SET_EIP(new_ip);                  if (CPU_STAT_SS32) {
                           CPU_ESP = tss_esp;
                   } else {
                           CPU_SP = (WORD)tss_esp;
                   }
   
                                         PUSH0_32(temp_cs);                  load_cs(cs_sel->selector, &cs_sel->desc, cs_sel->desc.dpl);
                                         PUSH0_32(temp_eip);                  SET_EIP(callgate_sel->desc.u.gate.offset);
                                 } else {  
                                         CHECK_STACK_PUSH(&CPU_STAT_SREG(CPU_SS_INDEX), CPU_ESP, 4);  
   
                                         load_cs(sel2.selector, &sel2.desc, CPU_STAT_CPL);  
                                         new_ip &= 0xffff;  
                                         SET_EIP(new_ip);  
   
                                         PUSH0_16(temp_cs);                  PUSH0_16(old_ss);
                                         PUSH0_16(temp_eip);                  PUSH0_16(old_esp);
                                 }  
                         }  
                         break;  
   
                 case CPU_SYSDESC_TYPE_TASK:                  /* restore param */
                         VERBOSE(("TASK-GATE"));                  for (i = param_count; i != 0; i--) {
                           PUSH0_16(param[i - 1]);
                           VERBOSE(("CALLfar_pm: set param[%d] = %04x", i - 1, param[i - 1]));
                   }
   
                         /* check privilege level */                  PUSH0_16(old_cs);
                         if ((call_sel.desc.dpl < CPU_STAT_CPL)                  PUSH0_16(old_eip);
                          || (call_sel.desc.dpl < call_sel.rpl)) {          }
                                 EXCEPTION(GP_EXCEPTION, call_sel.idx);  }
                         }  
   
                         /* not present */  /*---
                         if (selector_is_not_present(&call_sel)) {   * CALLfar_pm: task gate
                                 EXCEPTION(NP_EXCEPTION, call_sel.idx);   */
                         }  static void
   CALLfar_pm_task_gate(selector_t *taskgate_sel)
   {
           selector_t tss_sel;
           int rv;
   
                         /* tss descriptor */          VERBOSE(("CALLfar_pm: TASK-GATE"));
                         rv = parse_selector(&sel2, call_sel.desc.u.gate.selector);  
                         if (rv < 0 || sel2.ldt) {  
                                 EXCEPTION(GP_EXCEPTION, sel2.idx);  
                         }  
   
                         /* check descriptor type */          /* check privilege level */
                         switch (sel2.desc.type) {          if (taskgate_sel->desc.dpl < CPU_STAT_CPL) {
                         case CPU_SYSDESC_TYPE_TSS_16:                  VERBOSE(("CALLfar_pm: DPL(%d) < CPL(%d)", taskgate_sel->desc.dpl, CPU_STAT_CPL));
                         case CPU_SYSDESC_TYPE_TSS_32:                  EXCEPTION(GP_EXCEPTION, taskgate_sel->idx);
                                 break;          }
           if (taskgate_sel->desc.dpl < taskgate_sel->rpl) {
                         case CPU_SYSDESC_TYPE_TSS_BUSY_16:                  VERBOSE(("CALLfar_pm: DPL(%d) < CPL(%d)", taskgate_sel->desc.dpl, taskgate_sel->rpl));
                         case CPU_SYSDESC_TYPE_TSS_BUSY_32:                  EXCEPTION(GP_EXCEPTION, taskgate_sel->idx);
                                 VERBOSE(("CALLfar_pm: task is busy"));          }
                                 /*FALLTHROUGH*/  
                         default:  
                                 EXCEPTION(GP_EXCEPTION, sel2.idx);  
                                 break;  
                         }  
   
                         /* not present */          /* not present */
                         if (selector_is_not_present(&sel2)) {          if (selector_is_not_present(taskgate_sel)) {
                                 EXCEPTION(NP_EXCEPTION, sel2.idx);                  VERBOSE(("CALLfar_pm: selector is not present"));
                         }                  EXCEPTION(NP_EXCEPTION, taskgate_sel->idx);
           }
   
                         task_switch(&sel2, TASK_SWITCH_CALL);          /* tss descriptor */
           rv = parse_selector(&tss_sel, taskgate_sel->desc.u.gate.selector);
           if (rv < 0 || tss_sel.ldt) {
                   VERBOSE(("CALLfar_pm: parse_selector (selector = %04x, rv = %d, %s)", tss_sel.selector, rv, tss_sel.ldt ? "LDT" : "GDT"));
                   EXCEPTION(GP_EXCEPTION, tss_sel.idx);
           }
   
                         /* out of range */          /* check descriptor type */
                         if (CPU_EIP > CPU_STAT_CS_LIMIT) {          switch (tss_sel.desc.type) {
                                 EXCEPTION(GP_EXCEPTION, 0);          case CPU_SYSDESC_TYPE_TSS_16:
                         }          case CPU_SYSDESC_TYPE_TSS_32:
                         break;                  break;
   
           case CPU_SYSDESC_TYPE_TSS_BUSY_16:
           case CPU_SYSDESC_TYPE_TSS_BUSY_32:
                   VERBOSE(("CALLfar_pm: task is busy"));
                   /*FALLTHROUGH*/
           default:
                   VERBOSE(("CALLfar_pm: invalid descriptor type (type = %d)", tss_sel.desc.type));
                   EXCEPTION(GP_EXCEPTION, tss_sel.idx);
                   break;
           }
   
                 case CPU_SYSDESC_TYPE_TSS_16:          /* not present */
                 case CPU_SYSDESC_TYPE_TSS_32:          if (selector_is_not_present(&tss_sel)) {
                         VERBOSE(("TASK-STATE-SEGMENT"));                  VERBOSE(("CALLfar_pm: TSS selector is not present"));
                   EXCEPTION(NP_EXCEPTION, tss_sel.idx);
           }
   
                         /* check privilege level */          task_switch(&tss_sel, TASK_SWITCH_CALL);
                         if ((call_sel.desc.dpl < CPU_STAT_CPL)  }
                          || (call_sel.desc.dpl < call_sel.rpl)) {  
                                 EXCEPTION(GP_EXCEPTION, call_sel.idx);  
                         }  
   
                         /* not present */  /*---
                         if (selector_is_not_present(&call_sel)) {   * CALLfar_pm: TSS
                                 EXCEPTION(NP_EXCEPTION, call_sel.idx);   */
                         }  static void
   CALLfar_pm_tss(selector_t *tss_sel)
   {
   
                         task_switch(&call_sel, TASK_SWITCH_CALL);          VERBOSE(("TASK-STATE-SEGMENT"));
   
                         /* out of range */          /* check privilege level */
                         if (CPU_EIP > CPU_STAT_CS_LIMIT) {          if (tss_sel->desc.dpl < CPU_STAT_CPL) {
                                 EXCEPTION(GP_EXCEPTION, 0);                  VERBOSE(("CALLfar_pm: DPL(%d) < CPL(%d)", tss_sel->desc.dpl, CPU_STAT_CPL));
                         }                  EXCEPTION(GP_EXCEPTION, tss_sel->idx);
                         break;          }
           if (tss_sel->desc.dpl < tss_sel->rpl) {
                   VERBOSE(("CALLfar_pm: DPL(%d) < CPL(%d)", tss_sel->desc.dpl, tss_sel->rpl));
                   EXCEPTION(GP_EXCEPTION, tss_sel->idx);
           }
   
                 case CPU_SYSDESC_TYPE_TSS_BUSY_16:          /* not present */
                 case CPU_SYSDESC_TYPE_TSS_BUSY_32:          if (selector_is_not_present(tss_sel)) {
                         VERBOSE(("CALLfar_pm: task is busy"));                  VERBOSE(("CALLfar_pm: TSS selector is not present"));
                         /*FALLTHROUGH*/                  EXCEPTION(NP_EXCEPTION, tss_sel->idx);
                 default:  
                         EXCEPTION(GP_EXCEPTION, call_sel.idx);  
                         break;  
                 }  
         }          }
   
           task_switch(tss_sel, TASK_SWITCH_CALL);
 }  }
   
   
   /*------------------------------------------------------------------------------
    * RETfar_pm
    */
   
 /*  /*
  * 4.3.6. 特権レベル間のリターン操作   * 4.3.6. 特権レベル間のリターン操作
  *   *
Line 598  CALLfar_pm(WORD selector, DWORD new_ip) Line 842  CALLfar_pm(WORD selector, DWORD new_ip)
 void  void
 RETfar_pm(DWORD nbytes)  RETfar_pm(DWORD nbytes)
 {  {
         selector_t ret_sel;          selector_t ret_sel, ss_sel, temp_sel;
           DWORD sp;
           DWORD new_ip, new_sp;
           WORD new_cs, new_ss;
         int rv;          int rv;
         DWORD new_ip;          int i;
         WORD selector;  
   
         VERBOSE(("RETfar_pm: nbytes = %d", nbytes));          VERBOSE(("RETfar_pm: old EIP = %04x:%08x, ESP = %04x:%08x, nbytes = %d", CPU_CS, CPU_PREV_EIP, CPU_SS, CPU_ESP, nbytes));
   
           if (CPU_STAT_SS32) {
                   sp = CPU_ESP;
           } else {
                   sp = CPU_SP;
           }
         if (CPU_INST_OP32) {          if (CPU_INST_OP32) {
                 CHECK_STACK_POP(&CPU_STAT_SREG(CPU_SS_INDEX), CPU_ESP, 8 + nbytes);                  CHECK_STACK_POP(&CPU_STAT_SREG(CPU_SS_INDEX), sp, nbytes + 8);
                 if (CPU_STAT_SS32) {                  new_ip = cpu_vmemoryread_d(CPU_SS_INDEX, sp);
                         new_ip = cpu_vmemoryread_d(CPU_SS_INDEX, CPU_ESP);                  new_cs = cpu_vmemoryread_d(CPU_SS_INDEX, sp + 4);
                         selector = cpu_vmemoryread_d(CPU_SS_INDEX, CPU_ESP + 4);  
                 } else {  
                         new_ip = cpu_vmemoryread_d(CPU_SS_INDEX, CPU_SP);  
                         selector = cpu_vmemoryread_d(CPU_SS_INDEX, CPU_SP + 4);  
                 }  
         } else {          } else {
                 CHECK_STACK_POP(&CPU_STAT_SREG(CPU_SS_INDEX), CPU_ESP, 4 + nbytes);                  CHECK_STACK_POP(&CPU_STAT_SREG(CPU_SS_INDEX), sp, nbytes + 4);
                 if (CPU_STAT_SS32) {                  new_ip = cpu_vmemoryread_w(CPU_SS_INDEX, sp);
                         new_ip = cpu_vmemoryread_w(CPU_SS_INDEX, CPU_ESP);                  new_cs = cpu_vmemoryread_w(CPU_SS_INDEX, sp + 2);
                         selector = cpu_vmemoryread_w(CPU_SS_INDEX, CPU_ESP + 2);  
                 } else {  
                         new_ip = cpu_vmemoryread_w(CPU_SS_INDEX, CPU_SP);  
                         selector = cpu_vmemoryread_w(CPU_SS_INDEX, CPU_SP + 2);  
                 }  
         }          }
   
         rv = parse_selector(&ret_sel, selector);          rv = parse_selector(&ret_sel, new_cs);
         if (rv < 0) {          if (rv < 0) {
                   VERBOSE(("RETfar_pm: parse_selector (selector = %04x, rv = %d, %s)", ret_sel.selector, rv));
                 EXCEPTION(GP_EXCEPTION, ret_sel.idx);                  EXCEPTION(GP_EXCEPTION, ret_sel.idx);
         }          }
   
         /* check code segment descriptor */          /* check segment type */
         if (!ret_sel.desc.s || !ret_sel.desc.u.seg.c) {          if (!ret_sel.desc.s) {
                   VERBOSE(("RETfar_pm: return to system segment"));
                   EXCEPTION(GP_EXCEPTION, ret_sel.idx);
           }
           if (!ret_sel.desc.u.seg.c) {
                   VERBOSE(("RETfar_pm: return to data segment"));
                 EXCEPTION(GP_EXCEPTION, ret_sel.idx);                  EXCEPTION(GP_EXCEPTION, ret_sel.idx);
         }          }
   
         /* check privilege level */          /* check privilege level */
         if (ret_sel.rpl < CPU_STAT_CPL          if (ret_sel.rpl < CPU_STAT_CPL) {
          || (ret_sel.desc.u.seg.ec && (ret_sel.desc.dpl > ret_sel.rpl))) {                  VERBOSE(("RETfar_pm: RPL(%d) < CPL(%d)", ret_sel.rpl, CPU_STAT_CPL));
                   EXCEPTION(GP_EXCEPTION, ret_sel.idx);
           }
           if (!ret_sel.desc.u.seg.ec && (ret_sel.desc.dpl > ret_sel.rpl)) {
                   VERBOSE(("RETfar_pm: NON-COMFORMING-CODE-SEGMENT and DPL(%d) > RPL(%d)", ret_sel.desc.dpl, ret_sel.rpl));
                 EXCEPTION(GP_EXCEPTION, ret_sel.idx);                  EXCEPTION(GP_EXCEPTION, ret_sel.idx);
         }          }
   
         /* not present */          /* not present */
         if (selector_is_not_present(&ret_sel)) {          if (selector_is_not_present(&ret_sel)) {
                   VERBOSE(("RETfar_pm: returned code segment is not present"));
                 EXCEPTION(NP_EXCEPTION, ret_sel.idx);                  EXCEPTION(NP_EXCEPTION, ret_sel.idx);
         }          }
   
         if (ret_sel.rpl > CPU_STAT_CPL) {          if (ret_sel.rpl == CPU_STAT_CPL) {
                 selector_t ss_sel;                  VERBOSE(("RETfar_pm: RETURN-TO-SAME-PRIVILEGE-LEVEL"));
                 selector_t temp_sel;  
                 DWORD new_sp;                  /* check code segment limit */
                 WORD new_ss;                  if (new_ip > ret_sel.desc.u.seg.limit) {
                 int i;                          VERBOSE(("RETfar_pm: new_ip is out of range. new_ip = %08x, limit = %08x", new_ip, ret_sel.desc.u.seg.limit));
                           EXCEPTION(GP_EXCEPTION, 0);
                   }
   
                   VERBOSE(("RETfar_pm: new_ip = %08x, new_cs = %04x", new_ip, ret_sel.selector));
   
                   if (CPU_INST_OP32) {
                           nbytes += 8;
                   } else {
                           nbytes += 4;
                   }
                   if (CPU_STAT_SS32) {
                           CPU_ESP += nbytes;
                   } else {
                           CPU_SP += nbytes;
                   }
   
                 VERBOSE(("RETURN-OUTER-PRIVILEGE-LEVEL"));                  load_cs(ret_sel.selector, &ret_sel.desc, CPU_STAT_CPL);
                   SET_EIP(new_ip);
           } else {
                   VERBOSE(("RETfar_pm: RETURN-OUTER-PRIVILEGE-LEVEL"));
   
                 if (CPU_INST_OP32) {                  if (CPU_INST_OP32) {
                         CHECK_STACK_POP(&CPU_STAT_SREG(CPU_SS_INDEX), CPU_ESP, 16 + nbytes);                          CHECK_STACK_POP(&CPU_STAT_SREG(CPU_SS_INDEX), sp, 8 + 8 + nbytes);
                         if (CPU_STAT_SS32) {                          new_sp = cpu_vmemoryread_d(CPU_SS_INDEX, sp + 8 + nbytes);
                                 new_sp = cpu_vmemoryread_d(CPU_SS_INDEX, CPU_ESP + 8 + nbytes);                          new_ss = cpu_vmemoryread_w(CPU_SS_INDEX, sp + 8 + nbytes + 4);
                                 new_ss = (WORD)cpu_vmemoryread_d(CPU_SS_INDEX, CPU_ESP + 8 + 4 + nbytes);  
                         } else {  
                                 new_sp = cpu_vmemoryread_d(CPU_SS_INDEX, (WORD)(CPU_SP + 8 + nbytes));  
                                 new_ss = (WORD)cpu_vmemoryread_d(CPU_SS_INDEX, (WORD)(CPU_SP + 8 + 4 + nbytes));  
                         }  
                 } else {                  } else {
                         CHECK_STACK_POP(&CPU_STAT_SREG(CPU_SS_INDEX), CPU_ESP, 8 + nbytes);                          CHECK_STACK_POP(&CPU_STAT_SREG(CPU_SS_INDEX), sp, 4 + 4 + nbytes);
                         if (CPU_STAT_SS32) {                          new_sp = cpu_vmemoryread_w(CPU_SS_INDEX, sp + 4 + nbytes);
                                 new_sp = cpu_vmemoryread_w(CPU_SS_INDEX, CPU_ESP + 4 + nbytes);                          new_ss = cpu_vmemoryread_w(CPU_SS_INDEX, sp + 4 + nbytes + 2);
                                 new_ss = cpu_vmemoryread_w(CPU_SS_INDEX, CPU_ESP + 4 + 2 + nbytes);  
                         } else {  
                                 new_sp = cpu_vmemoryread_w(CPU_SS_INDEX, (WORD)(CPU_SP + 4 + nbytes));  
                                 new_ss = cpu_vmemoryread_w(CPU_SS_INDEX, (WORD)(CPU_SP + 4 + 2 + nbytes));  
                         }  
                 }                  }
   
                 rv = parse_selector(&ss_sel, new_ss);                  rv = parse_selector(&ss_sel, new_ss);
                 if (rv < 0) {                  if (rv < 0) {
                           VERBOSE(("RETfar_pm: parse_selector (selector = %04x, rv = %d, %s)", ss_sel.selector, rv));
                         EXCEPTION(GP_EXCEPTION, ss_sel.idx);                          EXCEPTION(GP_EXCEPTION, ss_sel.idx);
                 }                  }
   
                 /* check stack segment descriptor */                  /* check stack segment descriptor */
                   if (!ss_sel.desc.s) {
                           VERBOSE(("RETfar_pm: stack segment is system segment"));
                           EXCEPTION(GP_EXCEPTION, ret_sel.idx);
                   }
                   if (ss_sel.desc.u.seg.c) {
                           VERBOSE(("RETfar_pm: stack segment is code segment"));
                           EXCEPTION(GP_EXCEPTION, ret_sel.idx);
                   }
                   if (!ss_sel.desc.u.seg.wr) {
                           VERBOSE(("RETfar_pm: stack segment is read-only data segment"));
                           EXCEPTION(GP_EXCEPTION, ret_sel.idx);
                   }
   
                 /* check privilege level */                  /* check privilege level */
                 if ((ss_sel.rpl != ret_sel.rpl)                  if (ss_sel.rpl != ret_sel.rpl) {
                  || (ss_sel.desc.dpl != ret_sel.rpl)                          VERBOSE(("RETfar_pm: RPL[SS](%d) != RPL[CS](%d)", ss_sel.rpl, ret_sel.rpl));
                  || !ss_sel.desc.s                          EXCEPTION(GP_EXCEPTION, ret_sel.idx);
                  || !ss_sel.desc.u.seg.wr) {                  }
                         EXCEPTION(GP_EXCEPTION, ss_sel.idx);                  if (ss_sel.desc.dpl != ret_sel.rpl) {
                           VERBOSE(("RETfar_pm: DPL[SS](%d) != RPL[CS](%d)", ss_sel.desc.dpl, ret_sel.rpl));
                           EXCEPTION(GP_EXCEPTION, ret_sel.idx);
                 }                  }
   
                 /* not present */                  /* not present */
                 if (selector_is_not_present(&ss_sel)) {                  if (selector_is_not_present(&ss_sel)) {
                           VERBOSE(("RETfar_pm: stack segment is not present"));
                         EXCEPTION(SS_EXCEPTION, ss_sel.idx);                          EXCEPTION(SS_EXCEPTION, ss_sel.idx);
                 }                  }
   
                 /* check code segment limit */                  /* check code segment limit */
                 if (new_ip > ret_sel.desc.u.seg.limit) {                  if (new_ip > ret_sel.desc.u.seg.limit) {
                           VERBOSE(("RETfar_pm: new_ip is out of range. new_ip = %08x, limit = %08x", new_ip, ret_sel.desc.u.seg.limit));
                         EXCEPTION(GP_EXCEPTION, 0);                          EXCEPTION(GP_EXCEPTION, 0);
                 }                  }
   
                 /* set new register */                  VERBOSE(("RETfar_pm: new_ip = %08x, new_cs = %04x", new_ip, ret_sel.selector));
                   VERBOSE(("RETfar_pm: new_sp = %08x, new_ss = %04x", new_sp, ss_sel.selector));
   
                 load_cs(ret_sel.selector, &ret_sel.desc, ret_sel.rpl);                  load_cs(ret_sel.selector, &ret_sel.desc, ret_sel.rpl);
                 SET_EIP(new_ip);                  SET_EIP(new_ip);
   
                 load_ss(ss_sel.selector, &ss_sel.desc, ret_sel.rpl);                  load_ss(ss_sel.selector, &ss_sel.desc, ret_sel.rpl);
                 CPU_ESP = new_sp;                  if (CPU_STAT_SS32) {
                           CPU_ESP = new_sp + nbytes;
                   } else {
                           CPU_SP = new_sp + nbytes;
                   }
   
                 /* check segment register */                  /* check segment register */
                 for (i = 0; i < CPU_SEGREG_NUM; i++) {                  for (i = 0; i < CPU_SEGREG_NUM; i++) {
                         if (i == CPU_CS_INDEX || i == CPU_SS_INDEX)                          descriptor_t *dp;
                                 continue;                          BOOL valid;
   
                         rv = parse_selector(&temp_sel, CPU_REGS_SREG(i));                          dp = &CPU_STAT_SREG(i);
                         if (rv < 0) {                          if ((!dp->u.seg.c || !dp->u.seg.ec)
                            && (CPU_STAT_SREG(i).dpl < CPU_STAT_CPL)) {
                                   /* segment register is invalid */
                                 CPU_REGS_SREG(i) = 0;                                  CPU_REGS_SREG(i) = 0;
                                 CPU_STAT_SREG(i).valid = 0;                                  CPU_STAT_SREG_CLEAR(i);
                                 continue;                                  continue;
                         }                          }
   
                         /* check privilege level */                          rv = parse_selector(&temp_sel, CPU_REGS_SREG(i));
                         if (!temp_sel.desc.s                          if (rv < 0) {
                          || (temp_sel.desc.u.seg.c && temp_sel.desc.u.seg.wr)                                  /* segment register is invalid */
                          || ((!temp_sel.desc.u.seg.c || !temp_sel.desc.u.seg.ec)  
                            && ((temp_sel.desc.dpl < CPU_STAT_CPL) || (temp_sel.desc.dpl < temp_sel.rpl)))) {  
                                 CPU_REGS_SREG(i) = 0;                                  CPU_REGS_SREG(i) = 0;
                                 CPU_STAT_SREG(i).valid = 0;                                  CPU_STAT_SREG_CLEAR(i);
                                 continue;                                  continue;
                         }                          }
                 }  
                 CPU_ESP += nbytes;  
         } else {  
                 VERBOSE(("RETURN-TO-SAME-PRIVILEGE-LEVEL"));  
   
                 if (CPU_INST_OP32) {                          valid = TRUE;
                         if (new_ip > ret_sel.desc.u.seg.limit) {                          if (!temp_sel.desc.s) {
                                 EXCEPTION(GP_EXCEPTION, 0);                                  /* system segment */
                                   valid = FALSE;
                           }
                           if (temp_sel.desc.u.seg.c && !temp_sel.desc.u.seg.wr) {
                                   /* execute-only code segment */
                                   valid = FALSE;
                           }
                           if (!temp_sel.desc.u.seg.c || !temp_sel.desc.u.seg.ec) {
                                   if (CPU_STAT_CPL > temp_sel.desc.dpl) {
                                           valid = FALSE;
                                   }
                         }                          }
                         POP0_32(CPU_EIP);  
                         POP0_32(CPU_CS);                          if (!valid) {
                 } else {                                  /* segment register is invalid */
                         new_ip &= 0xffff;                                  CPU_REGS_SREG(i) = 0;
                         if (new_ip > ret_sel.desc.u.seg.limit) {                                  CPU_STAT_SREG(i).valid = 0;
                                 EXCEPTION(GP_EXCEPTION, 0);  
                         }                          }
                         POP0_16(CPU_EIP);  
                         POP0_16(CPU_CS);  
                 }                  }
                 load_cs(ret_sel.selector, &ret_sel.desc, CPU_STAT_CPL);  
                 SET_EIP(new_ip);  
                 CPU_ESP += nbytes;  
         }          }
   
           VERBOSE(("RETfar_pm: new EIP = %04x:%08x, ESP = %04x:%08x", CPU_CS, CPU_EIP, CPU_SS, CPU_ESP));
 }  }
   
   
   /*------------------------------------------------------------------------------
    * IRET_pm
    */
   static void IRET_pm_nested_task(void);
   static void IRET_pm_return_to_vm86(DWORD new_ip, DWORD new_cs, DWORD new_flags);
   static void IRET_pm_return_from_vm86(DWORD new_ip, DWORD new_cs, DWORD new_flags);
   
 void  void
 IRET_pm()  IRET_pm(void)
 {  {
         selector_t iret_sel;          selector_t iret_sel, ss_sel;
           descriptor_t *dp;
           DWORD sp;
           DWORD stacksize;        /* for RETURN-TO-SAME-PRIVILEGE-LEVEL */
           DWORD mask = 0;
           DWORD new_ip, new_sp, new_flags;
           WORD new_cs, new_ss;
           int old_cpl;
         int rv;          int rv;
         DWORD new_ip, new_flags;          int i;
         WORD new_cs;  
   
         VERBOSE(("IRET_pm"));          VERBOSE(("IRET_pm: old EIP = %04x:%08x, old ESP = %04x:%08x", CPU_CS, CPU_PREV_EIP, CPU_SS, CPU_ESP));
   
           if (!(CPU_EFLAG & VM_FLAG) && (CPU_EFLAG & NT_FLAG)) {
                   /* TASK-RETURN: PE=1, VM=0, NT=1 */
                   IRET_pm_nested_task();
                   VERBOSE(("IRET_pm: new EIP = %04x:%08x, new ESP = %04x:%08x", CPU_CS, CPU_EIP, CPU_SS, CPU_ESP));
                   CPU_STAT_NERROR = 0;
                   return;
           }
   
           if (CPU_STAT_SS32) {
                   sp = CPU_ESP;
           } else {
                   sp = CPU_SP;
           }
           if (CPU_INST_OP32) {
                   CHECK_STACK_POP(&CPU_STAT_SREG(CPU_SS_INDEX), sp, 12);
                   new_ip = cpu_vmemoryread_d(CPU_SS_INDEX, sp);
                   new_cs = cpu_vmemoryread_w(CPU_SS_INDEX, sp + 4);
                   new_flags = cpu_vmemoryread_d(CPU_SS_INDEX, sp + 8);
           } else {
                   CHECK_STACK_POP(&CPU_STAT_SREG(CPU_SS_INDEX), sp, 6);
                   new_ip = cpu_vmemoryread_w(CPU_SS_INDEX, sp);
                   new_cs = cpu_vmemoryread_w(CPU_SS_INDEX, sp + 2);
                   new_flags = cpu_vmemoryread_w(CPU_SS_INDEX, sp + 4);
           }
           VERBOSE(("IRET_pm: new_ip = %08x, new_cs = %04x, new_eflags = %08x", new_ip, new_cs, new_flags));
   
         if (CPU_STAT_VM86) {          if (CPU_EFLAG & VM_FLAG) {
                 /* RETURN-FROM-VIRTUAL-8086-MODE */                  /* RETURN-FROM-VIRTUAL-8086-MODE */
                 VERBOSE(("Virtual-8086 mode: PE=1, VM=1"));                  IRET_pm_return_from_vm86(new_ip, new_cs, new_flags);
                 VERBOSE(("Processor is in virtual-8086 mode when IRET is executed and stays in virtual-8086 mode"));                  VERBOSE(("IRET_pm: new EIP = %04x:%08x, new ESP = %04x:%08x", CPU_CS, CPU_EIP, CPU_SS, CPU_ESP));
                   CPU_STAT_NERROR = 0;
                   return;
           }
   
           if (new_flags & VM_FLAG) {
                   /* RETURN-TO-VIRTUAL-8086-MODE */
                   IRET_pm_return_to_vm86(new_ip, new_cs, new_flags);
                   VERBOSE(("IRET_pm: new EIP = %04x:%08x, new ESP = %04x:%08x", CPU_CS, CPU_EIP, CPU_SS, CPU_ESP));
                   CPU_STAT_NERROR = 0;
                   return;
           }
   
                 if (CPU_STAT_IOPL == CPU_IOPL3) {          /* PROTECTED-MODE-RETURN */
                         VERBOSE(("Virtual mode: PE=1, VM=1, IOPL=3"));          VERBOSE(("IRET_pm: PE=1, VM=0 in flags image"));
                         if (CPU_INST_OP32) {  
                                 CHECK_STACK_POP(&CPU_STAT_SREG(CPU_SS_INDEX), CPU_ESP, 12);  
                                 POP0_32(new_ip);  
                                 POP0_32(new_cs);  
                                 POP0_32(new_flags);  
   
                                 set_eflags(new_flags, I_FLAG|RF_FLAG);  
                         } else {  
                                 CHECK_STACK_POP(&CPU_STAT_SREG(CPU_SS_INDEX), CPU_ESP, 6);  
                                 POP0_16(new_ip);  
                                 POP0_16(new_cs);  
                                 POP0_16(new_flags);  
   
                                 set_flags(new_flags, I_FLAG);          rv = parse_selector(&iret_sel, new_cs);
                         }          if (rv < 0) {
                         CPU_SET_SEGREG(CPU_CS_INDEX, new_cs);                  VERBOSE(("IRET_pm: parse_selector (selector = %04x, rv = %d)", iret_sel.selector, rv));
                         SET_EIP(new_ip);                  EXCEPTION(GP_EXCEPTION, iret_sel.idx);
                         return;          }
   
           /* check code segment descriptor */
           if (!iret_sel.desc.s) {
                   VERBOSE(("IRET_pm: return code segment is system segment"));
                   EXCEPTION(GP_EXCEPTION, iret_sel.idx);
           }
           if (!iret_sel.desc.u.seg.c) {
                   VERBOSE(("IRET_pm: return code segment is data segment"));
                   EXCEPTION(GP_EXCEPTION, iret_sel.idx);
           }
   
           /* check privilege level */
           if (iret_sel.rpl < CPU_STAT_CPL) {
                   VERBOSE(("IRET_pm: RPL(%d) < CPL(%d)", iret_sel.rpl, CPU_STAT_CPL));
                   EXCEPTION(GP_EXCEPTION, iret_sel.idx);
           }
           if (iret_sel.desc.u.seg.ec && (iret_sel.desc.dpl > iret_sel.rpl)) {
                   VERBOSE(("IRET_pm: CONFORMING-CODE-SEGMENT and DPL(%d) != RPL(%d)", iret_sel.desc.dpl, iret_sel.rpl));
                   EXCEPTION(GP_EXCEPTION, iret_sel.idx);
           }
   
           /* not present */
           if (selector_is_not_present(&iret_sel)) {
                   VERBOSE(("IRET_pm: code segment is not present"));
                   EXCEPTION(NP_EXCEPTION, iret_sel.idx);
           }
   
           if (iret_sel.rpl > CPU_STAT_CPL) {
                   VERBOSE(("IRET_pm: RETURN-OUTER-PRIVILEGE-LEVEL"));
   
                   if (CPU_INST_OP32) {
                           CHECK_STACK_POP(&CPU_STAT_SREG(CPU_SS_INDEX), sp, 20);
                           new_sp = cpu_vmemoryread_d(CPU_SS_INDEX, sp + 12);
                           new_ss = cpu_vmemoryread_w(CPU_SS_INDEX, sp + 16);
                   } else {
                           CHECK_STACK_POP(&CPU_STAT_SREG(CPU_SS_INDEX), sp, 10);
                           new_sp = cpu_vmemoryread_w(CPU_SS_INDEX, sp + 6);
                           new_ss = cpu_vmemoryread_w(CPU_SS_INDEX, sp + 8);
                 }                  }
                 VERBOSE(("trap to virtual-8086 monitor: PE=1, VM=1, IOPL<3"));                  VERBOSE(("IRET_pm: new_sp = 0x%08x, new_ss = 0x%04x", new_sp, new_ss));
                 EXCEPTION(GP_EXCEPTION, 0);  
         } else if (CPU_EFLAG & NT_FLAG) {  
                 VERBOSE(("TASK-RETURN: PE=1, VM=0, NT=1"));  
   
                 new_cs = get_link_selector_from_tss();                  rv = parse_selector(&ss_sel, new_ss);
                 rv = parse_selector(&iret_sel, new_cs);                  if (rv < 0) {
                 if (rv < 0 || iret_sel.ldt) {                          VERBOSE(("IRET_pm: parse_selector (selector = %04x, rv = %d)", ss_sel.selector, rv));
                         EXCEPTION(GP_EXCEPTION, iret_sel.idx);                          EXCEPTION(GP_EXCEPTION, ss_sel.idx);
                 }                  }
   
                 /* check system segment */                  /* check privilege level */
                 if (iret_sel.desc.s) {                  if (ss_sel.rpl != iret_sel.rpl) {
                         EXCEPTION(GP_EXCEPTION, iret_sel.idx);                          VERBOSE(("IRET_pm: RPL[SS](%d) != RPL[CS](%d)", ss_sel.rpl, iret_sel.rpl));
                           EXCEPTION(GP_EXCEPTION, ss_sel.idx);
                   }
                   if (ss_sel.desc.dpl != iret_sel.rpl) {
                           VERBOSE(("IRET_pm: DPL[SS](%d) != RPL[CS](%d)", ss_sel.desc.dpl, iret_sel.rpl));
                           EXCEPTION(GP_EXCEPTION, ss_sel.idx);
                 }                  }
                 switch (iret_sel.desc.type) {  
                 case CPU_SYSDESC_TYPE_TSS_BUSY_16:  
                 case CPU_SYSDESC_TYPE_TSS_BUSY_32:  
                         break;  
   
                 case CPU_SYSDESC_TYPE_TSS_16:                  /* check stack segment descriptor */
                 case CPU_SYSDESC_TYPE_TSS_32:                  if (!ss_sel.desc.s) {
                         VERBOSE(("IRET_pm: task is not busy"));                          VERBOSE(("IRET_pm: stack segment is system segment"));
                         /*FALLTHROUGH*/                          EXCEPTION(GP_EXCEPTION, ss_sel.idx);
                 default:                  }
                         EXCEPTION(GP_EXCEPTION, iret_sel.idx);                  if (ss_sel.desc.u.seg.c) {
                         break;                          VERBOSE(("IRET_pm: stack segment is code segment"));
                           EXCEPTION(GP_EXCEPTION, ss_sel.idx);
                   }
                   if (!ss_sel.desc.u.seg.wr) {
                           VERBOSE(("IRET_pm: stack segment is read-only data segment"));
                           EXCEPTION(GP_EXCEPTION, ss_sel.idx);
                 }                  }
   
                 /* not present */                  /* not present */
                 if (selector_is_not_present(&iret_sel)) {                  if (selector_is_not_present(&ss_sel)) {
                         EXCEPTION(NP_EXCEPTION, iret_sel.idx);                          VERBOSE(("IRET_pm: stack segment is not present"));
                           EXCEPTION(SS_EXCEPTION, ss_sel.idx);
                 }                  }
   
                 task_switch(&iret_sel, TASK_SWITCH_IRET);                  /* compiler happy :-) */
                   stacksize = 0;
           } else {
                   VERBOSE(("IRET_pm: RETURN-TO-SAME-PRIVILEGE-LEVEL"));
   
                 /* out of range */                  if (CPU_INST_OP32) {
                 if (CPU_EIP > CPU_STAT_CS_LIMIT) {                          stacksize = 12;
                         EXCEPTION(GP_EXCEPTION, 0);                  } else {
                           stacksize = 6;
                 }                  }
         } else {  
                   /* compiler happy :-) */
                   new_sp = 0;
                   new_ss = 0;
           }
   
           /* check code segment limit */
           if (new_ip > iret_sel.desc.u.seg.limit) {
                   VERBOSE(("IRET_pm: new_ip is out of range. new_ip = %08x, limit = %08x", new_ip, iret_sel.desc.u.seg.limit));
                   EXCEPTION(GP_EXCEPTION, 0);
           }
   
           mask = 0;
           if (CPU_INST_OP32)
                   mask |= RF_FLAG;
           if (CPU_STAT_CPL <= CPU_STAT_IOPL)
                   mask |= I_FLAG;
           if (CPU_STAT_CPL == 0) {
                   mask |= IOPL_FLAG;
                 if (CPU_INST_OP32) {                  if (CPU_INST_OP32) {
                         CHECK_STACK_POP(&CPU_STAT_SREG(CPU_SS_INDEX), CPU_ESP, 12);                          mask |= VM_FLAG|VIF_FLAG|VIP_FLAG;
                         POP0_32(new_ip);                  }
                         POP0_32(new_cs);          }
                         POP0_32(new_flags);  
                 } else {          /* set new register */
                         CHECK_STACK_POP(&CPU_STAT_SREG(CPU_SS_INDEX), CPU_ESP, 6);          old_cpl = CPU_STAT_CPL;
                         POP0_16(new_ip);          load_cs(iret_sel.selector, &iret_sel.desc, iret_sel.rpl);
                         POP0_16(new_cs);          SET_EIP(new_ip);
                         POP0_16(new_flags);          set_eflags(new_flags, mask);
                 }  
           if (iret_sel.rpl > old_cpl) {
                 if ((CPU_STAT_CPL == 0) && (new_flags & VM_FLAG)) {                  /* RETURN-OUTER-PRIVILEGE-LEVEL */
                         /* RETURN-TO-VIRTUAL-8086-MODE */  
                         descriptor_t sd;                  load_ss(ss_sel.selector, &ss_sel.desc, iret_sel.rpl);
                         DWORD new_sp;                  if (CPU_STAT_SS32) {
                         WORD segsel[CPU_SEGREG_NUM];  
                         int i;  
   
                         VERBOSE(("Interrupt procedure was in virtual-8086 mode: PE=1, VM=1 in flags image"));  
   
                         CHECK_STACK_POP(&CPU_STAT_SREG(CPU_SS_INDEX), CPU_ESP, 24);  
   
                         segsel[CPU_CS_INDEX] = new_cs;  
                         POP0_32(new_sp);  
                         POP0_32(segsel[CPU_SS_INDEX]);  
                         POP0_32(segsel[CPU_ES_INDEX]);  
                         POP0_32(segsel[CPU_DS_INDEX]);  
                         POP0_32(segsel[CPU_FS_INDEX]);  
                         POP0_32(segsel[CPU_GS_INDEX]);  
   
                         for (i = 0; i < CPU_SEGREG_NUM; i++) {  
                                 CPU_REGS_SREG(i) = segsel[i];  
                                 sd.u.seg.limit = 0xffff;  
                                 CPU_SET_SEGDESC_DEFAULT(&sd, i, segsel[i]);  
                                 sd.dpl = 3;  
                                 CPU_STAT_SREG(i) = sd;  
                         }  
                         CPU_ESP = new_sp;                          CPU_ESP = new_sp;
                         SET_EIP(new_ip & 0xffff);                  } else {
                           CPU_SP = new_sp;
                   }
   
                         set_eflags(new_flags, IOPL_FLAG|RF_FLAG);                  /* check segment register */
                   for (i = 0; i < CPU_SEGREG_NUM; i++) {
                           if ((i != CPU_CS_INDEX) && (i != CPU_SS_INDEX)) {
                                   dp = &CPU_STAT_SREG(i);
                                   if ((!dp->u.seg.c || !dp->u.seg.ec)
                                    && (CPU_STAT_SREG(i).dpl < CPU_STAT_CPL)) {
                                           /* segment register is invalid */
                                           CPU_REGS_SREG(i) = 0;
                                           CPU_STAT_SREG_CLEAR(i);
                                           continue;
                                   }
                           }
                   }
           } else {
                   /* RETURN-TO-SAME-PRIVILEGE-LEVEL */
                   if (CPU_STAT_SS32) {
                           CPU_ESP += stacksize;
                 } else {                  } else {
                         DWORD mask;                          CPU_SP += stacksize;
                   }
           }
           CPU_STAT_NERROR = 0;
   
                         /* PROTECTED-MODE-RETURN */          VERBOSE(("IRET_pm: new EIP = %04x:%08x, new ESP = %04x:%08x", CPU_CS, CPU_EIP, CPU_SS, CPU_ESP));
                         VERBOSE(("PE=1, VM=0 in flags image"));  }
   
                         rv = parse_selector(&iret_sel, new_cs);  /*---
                         if (rv < 0) {   * IRET_pm: NT_FLAG
                                 EXCEPTION(GP_EXCEPTION, iret_sel.idx);   */
                         }  static void
   IRET_pm_nested_task(void)
   {
           selector_t tss_sel;
           int rv;
           WORD new_tss;
   
                         /* check code segment descriptor */          VERBOSE(("IRET_pm: TASK-RETURN: PE=1, VM=0, NT=1"));
                         if (!iret_sel.desc.s || !iret_sel.desc.u.seg.c) {  
                                 EXCEPTION(GP_EXCEPTION, iret_sel.idx);  
                         }  
   
                         /* check privilege level */          new_tss = get_link_selector_from_tss();
                         if ((iret_sel.rpl < CPU_STAT_CPL)          rv = parse_selector(&tss_sel, new_tss);
                          || (iret_sel.desc.u.seg.ec && (iret_sel.desc.dpl > iret_sel.rpl))) {          if (rv < 0 || tss_sel.ldt) {
                                 EXCEPTION(GP_EXCEPTION, iret_sel.idx);                  VERBOSE(("IRET_pm: parse_selector (selector = %04x, rv = %d, %cDT)", tss_sel.selector, rv, tss_sel.ldt ? 'L' : 'G'));
                         }                  EXCEPTION(GP_EXCEPTION, tss_sel.idx);
           }
   
                         /* not present */          /* check system segment */
                         if (selector_is_not_present(&iret_sel)) {          if (tss_sel.desc.s) {
                                 EXCEPTION(NP_EXCEPTION, iret_sel.idx);                  VERBOSE(("IRET_pm: task segment is %d segment", tss_sel.desc.u.seg.c ? "code" : "data"));
                         }                  EXCEPTION(GP_EXCEPTION, tss_sel.idx);
           }
   
                         if (iret_sel.rpl > CPU_STAT_CPL) {          switch (tss_sel.desc.type) {
                                 /* RETURN-OUTER-PRIVILEGE-LEVEL */          case CPU_SYSDESC_TYPE_TSS_BUSY_16:
                                 selector_t ss_sel;          case CPU_SYSDESC_TYPE_TSS_BUSY_32:
                                 WORD new_sp, new_ss;                  break;
   
                                 if (CPU_INST_OP32) {          case CPU_SYSDESC_TYPE_TSS_16:
                                         CHECK_STACK_POP(&CPU_STAT_SREG(CPU_SS_INDEX), CPU_ESP, 8);          case CPU_SYSDESC_TYPE_TSS_32:
                                         if (CPU_STAT_SS32) {                  VERBOSE(("IRET_pm: task is not busy"));
                                                 new_sp = cpu_vmemoryread_d(CPU_SS_INDEX, CPU_ESP);                  /*FALLTHROUGH*/
                                                 new_ss = cpu_vmemoryread_d(CPU_SS_INDEX, CPU_ESP + 4);          default:
                                         } else {                  VERBOSE(("IRET_pm: invalid descriptor type (type = %d)", tss_sel.desc.type));
                                                 new_sp = cpu_vmemoryread_d(CPU_SS_INDEX, CPU_SP);                  EXCEPTION(GP_EXCEPTION, tss_sel.idx);
                                                 new_ss = cpu_vmemoryread_d(CPU_SS_INDEX, CPU_SP + 4);                  break;
                                         }          }
                                 } else {  
                                         CHECK_STACK_POP(&CPU_STAT_SREG(CPU_SS_INDEX), CPU_ESP, 4);  
                                         if (CPU_STAT_SS32) {  
                                                 new_sp = cpu_vmemoryread_w(CPU_SS_INDEX, CPU_ESP);  
                                                 new_ss = cpu_vmemoryread_w(CPU_SS_INDEX, CPU_ESP + 2);  
                                         } else {  
                                                 new_sp = cpu_vmemoryread_w(CPU_SS_INDEX, CPU_SP);  
                                                 new_ss = cpu_vmemoryread_w(CPU_SS_INDEX, CPU_SP + 2);  
                                         }  
                                 }  
   
                                 rv = parse_selector(&ss_sel, new_ss);          /* not present */
                                 if (rv < 0) {          if (selector_is_not_present(&tss_sel)) {
                                         EXCEPTION(GP_EXCEPTION, ss_sel.idx);                  VERBOSE(("IRET_pm: tss segment is not present"));
                                 }                  EXCEPTION(NP_EXCEPTION, tss_sel.idx);
           }
   
                                 /* check stack segment descriptor */          task_switch(&tss_sel, TASK_SWITCH_IRET);
                                 /* check privilege level */  }
                                 if ((ss_sel.rpl != iret_sel.rpl)  
                                  || (ss_sel.desc.dpl != iret_sel.rpl)  
                                  || !ss_sel.desc.s  
                                  || !ss_sel.desc.u.seg.wr) {  
                                         EXCEPTION(GP_EXCEPTION, ss_sel.idx);  
                                 }  
   
                                 /* not present */  /*---
                                 if (selector_is_not_present(&ss_sel)) {   * IRET_pm: new_flags & VM_FLAG
                                         EXCEPTION(SS_EXCEPTION, ss_sel.idx);   */
                                 }  static void
                         } else {  IRET_pm_return_to_vm86(DWORD new_ip, DWORD new_cs, DWORD new_flags)
                                 VERBOSE(("RETURN-TO-SAME-PRIVILEGE-LEVEL"));  {
                         }          WORD segsel[CPU_SEGREG_NUM];
           DWORD sp;
           DWORD new_sp;
           int i;
   
                         /* check code segment limit */          VERBOSE(("IRET_pm: Interrupt procedure was in virtual-8086 mode: PE=1, VM=1 in flags image"));
                         if (new_ip > iret_sel.desc.u.seg.limit) {  
                                 EXCEPTION(GP_EXCEPTION, 0);  
                         }  
   
                         /* set new register */          if (CPU_STAT_CPL != 0) {
                         load_cs(iret_sel.selector, &iret_sel.desc, iret_sel.rpl);                  ia32_panic("IRET_pm: CPL != 0");
                         SET_EIP(new_ip);          }
   
                         mask = 0;  
                         if (CPU_INST_OP32)  
                                 mask |= RF_FLAG;  
                         if (CPU_STAT_CPL <= CPU_STAT_IOPL)  
                                 mask |= I_FLAG;  
                         if (CPU_STAT_CPL == 0) {  
                                 mask |= IOPL_FLAG;  
                                 if (CPU_INST_OP32)  
                                         mask |= VM_FLAG|VIF_FLAG|VIP_FLAG;  
                         }  
                         set_eflags(new_flags, mask);  
   
                         if (iret_sel.rpl > CPU_STAT_CPL) {          if (CPU_STAT_SS32) {
                                 selector_t temp_sel;                  sp = CPU_ESP;
                                 int i;          } else {
                   sp = CPU_SP;
                                 /* RETURN-OUTER-PRIVILEGE-LEVEL */          }
                                 /* check segment register */          if (!CPU_INST_OP32) {
                                 for (i = 0; i < CPU_SEGREG_NUM; i++) {                  ia32_panic("IRET_pm: 16bit mode");
                                         if ((i == CPU_CS_INDEX) || (i == CPU_SS_INDEX))          }
                                                 continue;  
           CHECK_STACK_POP(&CPU_STAT_SREG(CPU_SS_INDEX), sp, 36);
                                         rv = parse_selector(&temp_sel, CPU_REGS_SREG(i));          new_sp = cpu_vmemoryread_d(CPU_SS_INDEX, sp + 12);
                                         if (rv < 0) {          segsel[CPU_SS_INDEX] = cpu_vmemoryread_w(CPU_SS_INDEX, sp + 16);
                                                 CPU_REGS_SREG(i) = 0;          segsel[CPU_ES_INDEX] = cpu_vmemoryread_w(CPU_SS_INDEX, sp + 20);
                                                 CPU_STAT_SREG(i).valid = 0;          segsel[CPU_DS_INDEX] = cpu_vmemoryread_w(CPU_SS_INDEX, sp + 24);
                                                 continue;          segsel[CPU_FS_INDEX] = cpu_vmemoryread_w(CPU_SS_INDEX, sp + 28);
                                         }          segsel[CPU_GS_INDEX] = cpu_vmemoryread_w(CPU_SS_INDEX, sp + 32);
           segsel[CPU_CS_INDEX] = new_cs;
                                         if ((!temp_sel.desc.u.seg.c || !temp_sel.desc.u.seg.ec)  
                                          && (CPU_STAT_CPL > temp_sel.desc.dpl)) {          for (i = 0; i < CPU_SEGREG_NUM; i++) {
                                                 CPU_REGS_SREG(i) = 0;                  CPU_REGS_SREG(i) = segsel[i];
                                                 CPU_STAT_SREG(i).valid = 0;          }
                                                 continue;  
                                         }          set_eflags(new_flags, IOPL_FLAG|I_FLAG|VM_FLAG|RF_FLAG);
                                 }  
                         }          CPU_ESP = new_sp;
           SET_EIP(new_ip);
   }
   
   /*---
    * IRET_pm: VM_FLAG
    */
   static void
   IRET_pm_return_from_vm86(DWORD new_ip, DWORD new_cs, DWORD new_flags)
   {
           DWORD stacksize;
   
           VERBOSE(("IRET_pm: virtual-8086 mode: VM=1"));
   
           if (CPU_STAT_IOPL == CPU_IOPL3) {
                   VERBOSE(("IRET_pm: virtual-8086 mode: IOPL=3"));
                   if (CPU_INST_OP32) {
                           stacksize = 12;
                   } else {
                           stacksize = 6;
                   }
                   if (CPU_STAT_SS32) {
                           CPU_ESP += stacksize;
                   } else {
                           CPU_SP += stacksize;
                 }                  }
   
                   set_eflags(new_flags, I_FLAG|RF_FLAG);
   
                   CPU_SET_SEGREG(CPU_CS_INDEX, new_cs);
                   SET_EIP(new_ip);
                   return;
         }          }
           VERBOSE(("IRET_pm: trap to virtual-8086 monitor: VM=1, IOPL<3"));
           EXCEPTION(GP_EXCEPTION, 0);
 }  }
Removed from v.1.1  
changed lines
  Added in v.1.8

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