cpu/segment_ctrl.cc

   1 /////////////////////////////////////////////////////////////////////////
   2 // $Id: segment_ctrl.cc,v 1.21 2008/08/08 09:22:48 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
  29 #define NEED_CPU_REG_SHORTCUTS 1
  30 #include "bochs.h"
  31 #include "cpu.h"
  32 #define LOG_THIS BX_CPU_THIS_PTR
  33
  34 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LES_GwMp(bxInstruction_c *i)
  35 {
  36   Bit16u reg_16, es;
  37
  38   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
  39
  40   reg_16 = read_virtual_word(i->seg(), eaddr);
  41   es     = read_virtual_word(i->seg(), eaddr + 2);
  42
  43   load_seg_reg(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES], es);
  44
  45   BX_WRITE_16BIT_REG(i->nnn(), reg_16);
  46 }
  47
  48 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LES_GdMp(bxInstruction_c *i)
  49 {
  50   Bit16u es;
  51   Bit32u reg_32;
  52
  53   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
  54
  55   reg_32 = read_virtual_dword(i->seg(), eaddr);
  56   es     = read_virtual_word (i->seg(), eaddr + 4);
  57
  58   load_seg_reg(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_ES], es);
  59
  60   BX_WRITE_32BIT_REGZ(i->nnn(), reg_32);
  61 }
  62
  63 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LDS_GwMp(bxInstruction_c *i)
  64 {
  65   Bit16u reg_16, ds;
  66
  67   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
  68
  69   reg_16 = read_virtual_word(i->seg(), eaddr);
  70   ds     = read_virtual_word(i->seg(), eaddr + 2);
  71
  72   load_seg_reg(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS], ds);
  73
  74   BX_WRITE_16BIT_REG(i->nnn(), reg_16);
  75 }
  76
  77 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LDS_GdMp(bxInstruction_c *i)
  78 {
  79   Bit16u ds;
  80   Bit32u reg_32;
  81
  82   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
  83
  84   reg_32 = read_virtual_dword(i->seg(), eaddr);
  85   ds     = read_virtual_word (i->seg(), eaddr + 4);
  86
  87   load_seg_reg(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_DS], ds);
  88
  89   BX_WRITE_32BIT_REGZ(i->nnn(), reg_32);
  90 }
  91
  92 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LFS_GwMp(bxInstruction_c *i)
  93 {
  94   Bit16u reg_16, fs;
  95
  96   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
  97
  98   reg_16 = read_virtual_word(i->seg(), eaddr);
  99   fs     = read_virtual_word(i->seg(), eaddr + 2);
 100
 101   load_seg_reg(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS], fs);
 102
 103   BX_WRITE_16BIT_REG(i->nnn(), reg_16);
 104 }
 105
 106 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LFS_GdMp(bxInstruction_c *i)
 107 {
 108   Bit32u reg_32;
 109   Bit16u fs;
 110
 111   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 112
 113   reg_32 = read_virtual_dword(i->seg(), eaddr);
 114   fs     = read_virtual_word (i->seg(), eaddr + 4);
 115
 116   load_seg_reg(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS], fs);
 117
 118   BX_WRITE_32BIT_REGZ(i->nnn(), reg_32);
 119 }
 120
 121 #if BX_SUPPORT_X86_64
 122 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LFS_GqMp(bxInstruction_c *i)
 123 {
 124   Bit64u reg_64;
 125   Bit16u fs;
 126
 127   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 128
 129   reg_64 = read_virtual_qword(i->seg(), eaddr);
 130   fs     = read_virtual_word (i->seg(), eaddr + 8);
 131
 132   load_seg_reg(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_FS], fs);
 133
 134   BX_WRITE_64BIT_REG(i->nnn(), reg_64);
 135 }
 136 #endif
 137
 138 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LGS_GwMp(bxInstruction_c *i)
 139 {
 140   Bit16u reg_16, gs;
 141
 142   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 143
 144   reg_16 = read_virtual_word(i->seg(), eaddr);
 145   gs     = read_virtual_word(i->seg(), eaddr + 2);
 146
 147   load_seg_reg(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS], gs);
 148
 149   BX_WRITE_16BIT_REG(i->nnn(), reg_16);
 150 }
 151
 152 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LGS_GdMp(bxInstruction_c *i)
 153 {
 154   Bit32u reg_32;
 155   Bit16u gs;
 156
 157   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 158
 159   reg_32 = read_virtual_dword(i->seg(), eaddr);
 160   gs     = read_virtual_word (i->seg(), eaddr + 4);
 161
 162   load_seg_reg(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS], gs);
 163
 164   BX_WRITE_32BIT_REGZ(i->nnn(), reg_32);
 165 }
 166
 167 #if BX_SUPPORT_X86_64
 168 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LGS_GqMp(bxInstruction_c *i)
 169 {
 170   Bit64u reg_64;
 171   Bit16u gs;
 172
 173   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 174
 175   reg_64 = read_virtual_qword(i->seg(), eaddr);
 176   gs     = read_virtual_word (i->seg(), eaddr + 8);
 177
 178   load_seg_reg(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_GS], gs);
 179
 180   BX_WRITE_64BIT_REG(i->nnn(), reg_64);
 181 }
 182 #endif
 183
 184 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LSS_GwMp(bxInstruction_c *i)
 185 {
 186   Bit16u reg_16, ss;
 187
 188   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 189
 190   reg_16 = read_virtual_word(i->seg(), eaddr);
 191   ss     = read_virtual_word(i->seg(), eaddr + 2);
 192
 193   load_seg_reg(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS], ss);
 194
 195   BX_WRITE_16BIT_REG(i->nnn(), reg_16);
 196 }
 197
 198 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LSS_GdMp(bxInstruction_c *i)
 199 {
 200   Bit32u reg_32;
 201   Bit16u ss;
 202
 203   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 204
 205   reg_32 = read_virtual_dword(i->seg(), eaddr);
 206   ss     = read_virtual_word (i->seg(), eaddr + 4);
 207
 208   load_seg_reg(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS], ss);
 209
 210   BX_WRITE_32BIT_REGZ(i->nnn(), reg_32);
 211 }
 212
 213 #if BX_SUPPORT_X86_64
 214 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LSS_GqMp(bxInstruction_c *i)
 215 {
 216   Bit64u reg_64;
 217   Bit16u ss;
 218
 219   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 220
 221   reg_64 = read_virtual_qword(i->seg(), eaddr);
 222   ss     = read_virtual_word (i->seg(), eaddr + 8);
 223
 224   load_seg_reg(&BX_CPU_THIS_PTR sregs[BX_SEG_REG_SS], ss);
 225
 226   BX_WRITE_64BIT_REG(i->nnn(), reg_64);
 227 }
 228 #endif