cpu/soft_int.cc

   1 /////////////////////////////////////////////////////////////////////////
   2 // $Id: soft_int.cc,v 1.45 2008/10/01 09:44:40 sshwarts Exp $
   3 /////////////////////////////////////////////////////////////////////////
   4 //
   5 //  Copyright (C) 2001  MandrakeSoft S.A.
   6 //
   7 //    MandrakeSoft S.A.
   8 //    43, rue d'Aboukir
   9 //    75002 Paris - France
  10 //    http://www.linux-mandrake.com/
  11 //    http://www.mandrakesoft.com/
  12 //
  13 //  This library is free software; you can redistribute it and/or
  14 //  modify it under the terms of the GNU Lesser General Public
  15 //  License as published by the Free Software Foundation; either
  16 //  version 2 of the License, or (at your option) any later version.
  17 //
  18 //  This library is distributed in the hope that it will be useful,
  19 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21 //  Lesser General Public License for more details.
  22 //
  23 //  You should have received a copy of the GNU Lesser General Public
  24 //  License along with this library; if not, write to the Free Software
  25 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  26 /////////////////////////////////////////////////////////////////////////
  27
  28 #define NEED_CPU_REG_SHORTCUTS 1
  29 #include "bochs.h"
  30 #include "cpu.h"
  31 #define LOG_THIS BX_CPU_THIS_PTR
  32
  33 // Make code more tidy with a few macros.
  34 #if BX_SUPPORT_X86_64==0
  35 #define RSP ESP
  36 #endif
  37
  38 void BX_CPP_AttrRegparmN(1) BX_CPU_C::BOUND_GwMa(bxInstruction_c *i)
  39 {
  40   Bit16s bound_min, bound_max;
  41   Bit16s op1_16 = BX_READ_16BIT_REG(i->nnn());
  42
  43   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
  44
  45   bound_min = (Bit16s) read_virtual_word(i->seg(), eaddr);
  46   bound_max = (Bit16s) read_virtual_word(i->seg(), eaddr+2);
  47
  48   if (op1_16 < bound_min || op1_16 > bound_max) {
  49     BX_INFO(("BOUND_GdMa: fails bounds test"));
  50     exception(BX_BR_EXCEPTION, 0, 0);
  51   }
  52 }
  53
  54 void BX_CPP_AttrRegparmN(1) BX_CPU_C::BOUND_GdMa(bxInstruction_c *i)
  55 {
  56   Bit32s bound_min, bound_max;
  57   Bit32s op1_32 = BX_READ_32BIT_REG(i->nnn());
  58
  59   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
  60
  61   bound_min = (Bit32s) read_virtual_dword(i->seg(), eaddr);
  62   bound_max = (Bit32s) read_virtual_dword(i->seg(), eaddr+4);
  63
  64   if (op1_32 < bound_min || op1_32 > bound_max) {
  65     BX_INFO(("BOUND_GdMa: fails bounds test"));
  66     exception(BX_BR_EXCEPTION, 0, 0);
  67   }
  68 }
  69
  70 void BX_CPP_AttrRegparmN(1) BX_CPU_C::INT1(bxInstruction_c *i)
  71 {
  72   // This is an undocumented instrucion (opcode 0xf1)
  73   // which is useful for an ICE system.
  74
  75 #if BX_DEBUGGER
  76   BX_CPU_THIS_PTR show_flag |= Flag_softint;
  77 #endif
  78
  79   BX_CPU_THIS_PTR speculative_rsp = 1;
  80   BX_CPU_THIS_PTR prev_rsp = RSP;
  81
  82   // interrupt is not RSP safe
  83   interrupt(1, 1, 0, 0);
  84
  85   BX_CPU_THIS_PTR speculative_rsp = 0;
  86
  87   BX_INSTR_FAR_BRANCH(BX_CPU_ID, BX_INSTR_IS_INT,
  88                       BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.value,
  89                       EIP);
  90 }
  91
  92 void BX_CPP_AttrRegparmN(1) BX_CPU_C::INT3(bxInstruction_c *i)
  93 {
  94   // INT 3 is not IOPL sensitive
  95
  96 #if BX_DEBUGGER
  97   BX_CPU_THIS_PTR show_flag |= Flag_softint;
  98 #endif
  99
 100   BX_CPU_THIS_PTR speculative_rsp = 1;
 101   BX_CPU_THIS_PTR prev_rsp = RSP;
 102
 103   // interrupt is not RSP safe
 104   interrupt(3, 1, 0, 0);
 105
 106   BX_CPU_THIS_PTR speculative_rsp = 0;
 107
 108   BX_INSTR_FAR_BRANCH(BX_CPU_ID, BX_INSTR_IS_INT,
 109                       BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.value,
 110                       EIP);
 111 }
 112
 113
 114 void BX_CPP_AttrRegparmN(1) BX_CPU_C::INT_Ib(bxInstruction_c *i)
 115 {
 116 #if BX_DEBUGGER
 117   BX_CPU_THIS_PTR show_flag |= Flag_softint;
 118 #endif
 119
 120   Bit8u vector = i->Ib();
 121
 122   BX_CPU_THIS_PTR speculative_rsp = 1;
 123   BX_CPU_THIS_PTR prev_rsp = RSP;
 124
 125   if (v8086_mode()) {
 126 #if BX_SUPPORT_VME
 127     if (BX_CPU_THIS_PTR cr4.get_VME())
 128     {
 129       bx_address tr_base = BX_CPU_THIS_PTR tr.cache.u.system.base;
 130
 131       Bit16u io_base = system_read_word(tr_base + 102);
 132       Bit8u vme_redirection_bitmap = system_read_byte(tr_base + io_base - 32 + (vector >> 3));
 133
 134       if (! (vme_redirection_bitmap & (1 << (vector & 7))))
 135       {
 136         // redirect interrupt through virtual-mode idt
 137         v86_redirect_interrupt(vector);
 138         goto done;
 139       }
 140     }
 141 #endif
 142     // interrupt is not redirected or VME is OFF
 143     if (BX_CPU_THIS_PTR get_IOPL() < 3)
 144     {
 145       BX_DEBUG(("INT_Ib(): Interrupt cannot be redirected, generate #GP(0)"));
 146       exception(BX_GP_EXCEPTION, 0, 0);
 147     }
 148   }
 149
 150 #ifdef SHOW_EXIT_STATUS
 151   if ((vector == 0x21) && (AH == 0x4c)) {
 152     BX_INFO(("INT 21/4C called AL=0x%02x, BX=0x%04x", (unsigned) AL, (unsigned) BX));
 153   }
 154 #endif
 155
 156   interrupt(vector, 1, 0, 0);
 157
 158 done:
 159
 160   BX_CPU_THIS_PTR speculative_rsp = 0;
 161
 162   BX_INSTR_FAR_BRANCH(BX_CPU_ID, BX_INSTR_IS_INT,
 163                       BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.value,
 164                       EIP);
 165 }
 166
 167 void BX_CPP_AttrRegparmN(1) BX_CPU_C::INTO(bxInstruction_c *i)
 168 {
 169 #if BX_DEBUGGER
 170   BX_CPU_THIS_PTR show_flag |= Flag_softint;
 171 #endif
 172
 173   if (get_OF()) {
 174     BX_CPU_THIS_PTR speculative_rsp = 1;
 175     BX_CPU_THIS_PTR prev_rsp = RSP;
 176
 177     // interrupt is not RSP safe
 178     interrupt(4, 1, 0, 0);
 179
 180     BX_CPU_THIS_PTR speculative_rsp = 0;
 181
 182     BX_INSTR_FAR_BRANCH(BX_CPU_ID, BX_INSTR_IS_INT,
 183                         BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.value,
 184                         EIP);
 185   }
 186 }