cpu/soft_int.cc

   1 /////////////////////////////////////////////////////////////////////////
   2 // $Id: soft_int.cc,v 1.32 2006/08/31 18:18:17 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 #if BX_EXTERNAL_DEBUGGER
  34 #include "extdb.h"
  35 #endif
  36
  37 void BX_CPU_C::BOUND_GwMa(bxInstruction_c *i)
  38 {
  39   if (i->modC0()) {
  40     BX_INFO(("BOUND_GwMa: op2 must be memory reference"));
  41     UndefinedOpcode(i);
  42   }
  43
  44   Bit16s bound_min, bound_max;
  45   Bit16s op1_16 = BX_READ_16BIT_REG(i->nnn());
  46
  47   read_virtual_word(i->seg(), RMAddr(i),   (Bit16u *) &bound_min);
  48   read_virtual_word(i->seg(), RMAddr(i)+2, (Bit16u *) &bound_max);
  49
  50   if (op1_16 < bound_min || op1_16 > bound_max) {
  51     BX_INFO(("BOUND_GdMa: fails bounds test"));
  52     exception(BX_BR_EXCEPTION, 0, 0);
  53   }
  54 }
  55
  56 void BX_CPU_C::BOUND_GdMa(bxInstruction_c *i)
  57 {
  58   if (i->modC0()) {
  59     BX_INFO(("BOUND_GdMa: op2 must be memory reference"));
  60     UndefinedOpcode(i);
  61   }
  62
  63   Bit32s bound_min, bound_max;
  64   Bit32s op1_32 = BX_READ_32BIT_REG(i->nnn());
  65
  66   read_virtual_dword(i->seg(), RMAddr(i),   (Bit32u *) &bound_min);
  67   read_virtual_dword(i->seg(), RMAddr(i)+4, (Bit32u *) &bound_max);
  68
  69   if (op1_32 < bound_min || op1_32 > bound_max) {
  70     BX_INFO(("BOUND_GdMa: fails bounds test"));
  71     exception(BX_BR_EXCEPTION, 0, 0);
  72   }
  73 }
  74
  75 void BX_CPU_C::INT1(bxInstruction_c *i)
  76 {
  77   // This is an undocumented instrucion (opcode 0xf1)
  78   // which is useful for an ICE system.
  79
  80 #if BX_DEBUGGER
  81   BX_CPU_THIS_PTR show_flag |= Flag_softint;
  82 #endif
  83
  84 #if BX_EXTERNAL_DEBUGGER
  85   trap_debugger(0);
  86 #endif
  87
  88   interrupt(1, 1, 0, 0);
  89   BX_INSTR_FAR_BRANCH(BX_CPU_ID, BX_INSTR_IS_INT,
  90                       BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.value,
  91                       EIP);
  92 }
  93
  94 void BX_CPU_C::INT3(bxInstruction_c *i)
  95 {
  96   // INT 3 is not IOPL sensitive
  97
  98 #if BX_DEBUGGER
  99   BX_CPU_THIS_PTR show_flag |= Flag_softint;
 100 #endif
 101
 102   interrupt(3, 1, 0, 0);
 103   BX_INSTR_FAR_BRANCH(BX_CPU_ID, BX_INSTR_IS_INT,
 104                       BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.value,
 105                       EIP);
 106 }
 107
 108
 109 void BX_CPU_C::INT_Ib(bxInstruction_c *i)
 110 {
 111 #if BX_DEBUGGER
 112   BX_CPU_THIS_PTR show_flag |= Flag_softint;
 113 #endif
 114
 115   Bit8u vector = i->Ib();
 116
 117   if (v8086_mode()) {
 118 #if BX_SUPPORT_VME
 119     if (BX_CPU_THIS_PTR cr4.get_VME())
 120     {
 121       Bit8u vme_redirection_bitmap;
 122       Bit16u io_base;
 123
 124       access_linear(BX_CPU_THIS_PTR tr.cache.u.system.base + 102,
 125             2, 0, BX_READ, &io_base);
 126       access_linear(BX_CPU_THIS_PTR tr.cache.u.system.base + io_base - 32 + (vector >> 3),
 127             1, 0, BX_READ, &vme_redirection_bitmap);
 128
 129       if (! (vme_redirection_bitmap & (1 << (vector & 7))))
 130       {
 131         // redirect interrupt through virtual-mode idt
 132         v86_redirect_interrupt(vector);
 133         return;
 134       }
 135     }
 136 #endif
 137     // interrupt is not redirected or VME is OFF
 138     if (BX_CPU_THIS_PTR get_IOPL() < 3)
 139     {
 140       BX_DEBUG(("INT_Ib(): Interrupt cannot be redirected, generate #GP(0)"));
 141       exception(BX_GP_EXCEPTION, 0, 0);
 142     }
 143   }
 144
 145 #ifdef SHOW_EXIT_STATUS
 146   if ( (vector == 0x21) && (AH == 0x4c) ) {
 147     BX_INFO(("INT 21/4C called AL=0x%02x, BX=0x%04x", (unsigned) AL, (unsigned) BX));
 148   }
 149 #endif
 150
 151   interrupt(vector, 1, 0, 0);
 152   BX_INSTR_FAR_BRANCH(BX_CPU_ID, BX_INSTR_IS_INT,
 153                       BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.value,
 154                       EIP);
 155 }
 156
 157 void BX_CPU_C::INTO(bxInstruction_c *i)
 158 {
 159 #if BX_DEBUGGER
 160   BX_CPU_THIS_PTR show_flag |= Flag_softint;
 161 #endif
 162
 163   if (get_OF()) {
 164     interrupt(4, 1, 0, 0);
 165     BX_INSTR_FAR_BRANCH(BX_CPU_ID, BX_INSTR_IS_INT,
 166                         BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.value,
 167                         EIP);
 168   }
 169 }