cpu/load32.cc

   1 /////////////////////////////////////////////////////////////////////////
   2 // $Id: load32.cc,v 1.3 2008/12/11 21:19:38 sshwarts Exp $
   3 /////////////////////////////////////////////////////////////////////////
   4 //
   5 //   Copyright (c) 2008 Stanislav Shwartsman
   6 //          Written by Stanislav Shwartsman [sshwarts at sourceforge net]
   7 //
   8 //  This library is free software; you can redistribute it and/or
   9 //  modify it under the terms of the GNU Lesser General Public
  10 //  License as published by the Free Software Foundation; either
  11 //  version 2 of the License, or (at your option) any later version.
  12 //
  13 //  This library is distributed in the hope that it will be useful,
  14 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 //  Lesser General Public License for more details.
  17 //
  18 //  You should have received a copy of the GNU Lesser General Public
  19 //  License along with this library; if not, write to the Free Software
  20 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21 //
  22 /////////////////////////////////////////////////////////////////////////
  23
  24 #define NEED_CPU_REG_SHORTCUTS 1
  25 #include "bochs.h"
  26 #include "cpu.h"
  27 #define LOG_THIS BX_CPU_THIS_PTR
  28
  29 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LOAD_Eb(bxInstruction_c *i)
  30 {
  31   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
  32   TMP8L = read_virtual_byte(i->seg(), eaddr);
  33   BX_CPU_CALL_METHOD(i->execute2, (i));
  34 }
  35
  36 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LOAD_Eb_Resolve16BaseIndex(bxInstruction_c *i)
  37 {
  38   Bit16u offset = BX_READ_16BIT_REG(i->sibBase()) + BX_READ_16BIT_REG(i->sibIndex()) + (Bit16s) i->displ16u();
  39   Bit32u laddr;
  40
  41   unsigned s = i->seg();
  42   bx_segment_reg_t *seg = &BX_CPU_THIS_PTR sregs[s];
  43   BX_INSTR_MEM_DATA_ACCESS(BX_CPU_ID, s, offset, 1, BX_READ);
  44
  45   BX_ASSERT(BX_CPU_THIS_PTR cpu_mode != BX_MODE_LONG_64);
  46
  47   if (seg->cache.valid & SegAccessROK) {
  48     if (offset <= seg->cache.u.segment.limit_scaled) {
  49 accessOK:
  50       laddr = BX_CPU_THIS_PTR get_laddr32(s, offset);
  51       unsigned tlbIndex = BX_TLB_INDEX_OF(laddr, 0);
  52       Bit32u lpf = LPFOf(laddr);
  53       bx_TLB_entry *tlbEntry = &BX_CPU_THIS_PTR TLB.entry[tlbIndex];
  54       if (tlbEntry->lpf == lpf && ! (tlbEntry->accessBits & USER_PL)) {
  55         // See if the TLB entry privilege level allows us read access
  56         // from this CPL.
  57         bx_hostpageaddr_t hostPageAddr = tlbEntry->hostPageAddr;
  58         Bit32u pageOffset = PAGE_OFFSET(laddr);
  59         Bit8u *hostAddr = (Bit8u*) (hostPageAddr | pageOffset);
  60         TMP8L = *hostAddr;
  61         BX_INSTR_LIN_ACCESS(BX_CPU_ID, laddr, tlbEntry->ppf | pageOffset, 1, BX_READ);
  62         BX_DBG_LIN_MEMORY_ACCESS(BX_CPU_ID, laddr,
  63               tlbEntry->ppf | pageOffset, 1, CPL, BX_READ, (Bit8u*) &TMP8L);
  64       }
  65       else {
  66         access_read_linear(laddr, 1, CPL, BX_READ, (void *) &TMP8L);
  67       }
  68
  69       BX_CPU_CALL_METHOD(i->execute2, (i));
  70       return;
  71     }
  72     else {
  73       BX_ERROR(("LOAD_Eb(): segment limit violation"));
  74       exception(int_number(s), 0, 0);
  75     }
  76   }
  77
  78   if (!read_virtual_checks(seg, offset, 1))
  79     exception(int_number(s), 0, 0);
  80   goto accessOK;
  81 }
  82
  83 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LOAD_Eb_Resolve32Base(bxInstruction_c *i)
  84 {
  85   Bit32u offset = BX_READ_32BIT_REG(i->sibBase()) + (Bit32s) i->displ32u();
  86   Bit32u laddr;
  87
  88   unsigned s = i->seg();
  89   bx_segment_reg_t *seg = &BX_CPU_THIS_PTR sregs[s];
  90   BX_INSTR_MEM_DATA_ACCESS(BX_CPU_ID, s, offset, 1, BX_READ);
  91
  92   BX_ASSERT(BX_CPU_THIS_PTR cpu_mode != BX_MODE_LONG_64);
  93
  94   if (seg->cache.valid & SegAccessROK) {
  95     if (offset <= seg->cache.u.segment.limit_scaled) {
  96 accessOK:
  97       laddr = BX_CPU_THIS_PTR get_laddr32(s, offset);
  98       unsigned tlbIndex = BX_TLB_INDEX_OF(laddr, 0);
  99       Bit32u lpf = LPFOf(laddr);
 100       bx_TLB_entry *tlbEntry = &BX_CPU_THIS_PTR TLB.entry[tlbIndex];
 101       if (tlbEntry->lpf == lpf && ! (tlbEntry->accessBits & USER_PL)) {
 102         // See if the TLB entry privilege level allows us read access
 103         // from this CPL.
 104         bx_hostpageaddr_t hostPageAddr = tlbEntry->hostPageAddr;
 105         Bit32u pageOffset = PAGE_OFFSET(laddr);
 106         Bit8u *hostAddr = (Bit8u*) (hostPageAddr | pageOffset);
 107         TMP8L = *hostAddr;
 108         BX_INSTR_LIN_ACCESS(BX_CPU_ID, laddr, tlbEntry->ppf | pageOffset, 1, BX_READ);
 109         BX_DBG_LIN_MEMORY_ACCESS(BX_CPU_ID, laddr,
 110               tlbEntry->ppf | pageOffset, 1, CPL, BX_READ, (Bit8u*) &TMP8L);
 111       }
 112       else {
 113         access_read_linear(laddr, 1, CPL, BX_READ, (void *) &TMP8L);
 114       }
 115
 116       BX_CPU_CALL_METHOD(i->execute2, (i));
 117       return;
 118     }
 119     else {
 120       BX_ERROR(("LOAD_Eb(): segment limit violation"));
 121       exception(int_number(s), 0, 0);
 122     }
 123   }
 124
 125   if (!read_virtual_checks(seg, offset, 1))
 126     exception(int_number(s), 0, 0);
 127   goto accessOK;
 128 }
 129
 130 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LOAD_Eb_Resolve32BaseIndex(bxInstruction_c *i)
 131 {
 132   Bit32u offset = BX_READ_32BIT_REG(i->sibBase()) + (BX_READ_32BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
 133   Bit32u laddr;
 134
 135   unsigned s = i->seg();
 136   bx_segment_reg_t *seg = &BX_CPU_THIS_PTR sregs[s];
 137   BX_INSTR_MEM_DATA_ACCESS(BX_CPU_ID, s, offset, 1, BX_READ);
 138
 139   BX_ASSERT(BX_CPU_THIS_PTR cpu_mode != BX_MODE_LONG_64);
 140
 141   if (seg->cache.valid & SegAccessROK) {
 142     if (offset <= seg->cache.u.segment.limit_scaled) {
 143 accessOK:
 144       laddr = BX_CPU_THIS_PTR get_laddr32(s, offset);
 145       unsigned tlbIndex = BX_TLB_INDEX_OF(laddr, 0);
 146       Bit32u lpf = LPFOf(laddr);
 147       bx_TLB_entry *tlbEntry = &BX_CPU_THIS_PTR TLB.entry[tlbIndex];
 148       if (tlbEntry->lpf == lpf && ! (tlbEntry->accessBits & USER_PL)) {
 149         // See if the TLB entry privilege level allows us read access
 150         // from this CPL.
 151         bx_hostpageaddr_t hostPageAddr = tlbEntry->hostPageAddr;
 152         Bit32u pageOffset = PAGE_OFFSET(laddr);
 153         Bit8u *hostAddr = (Bit8u*) (hostPageAddr | pageOffset);
 154         TMP8L = *hostAddr;
 155         BX_INSTR_LIN_ACCESS(BX_CPU_ID, laddr, tlbEntry->ppf | pageOffset, 1, BX_READ);
 156         BX_DBG_LIN_MEMORY_ACCESS(BX_CPU_ID, laddr,
 157               tlbEntry->ppf | pageOffset, 1, CPL, BX_READ, (Bit8u*) &TMP8L);
 158       }
 159       else {
 160         access_read_linear(laddr, 1, CPL, BX_READ, (void *) &TMP8L);
 161       }
 162
 163       BX_CPU_CALL_METHOD(i->execute2, (i));
 164       return;
 165     }
 166     else {
 167       BX_ERROR(("LOAD_Eb(): segment limit violation"));
 168       exception(int_number(s), 0, 0);
 169     }
 170   }
 171
 172   if (!read_virtual_checks(seg, offset, 1))
 173     exception(int_number(s), 0, 0);
 174   goto accessOK;
 175 }
 176
 177 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LOAD_Ew(bxInstruction_c *i)
 178 {
 179   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 180   TMP16 = read_virtual_word(i->seg(), eaddr);
 181   BX_CPU_CALL_METHOD(i->execute2, (i));
 182 }
 183
 184 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LOAD_Ew_Resolve16BaseIndex(bxInstruction_c *i)
 185 {
 186   Bit16u offset = BX_READ_16BIT_REG(i->sibBase()) + BX_READ_16BIT_REG(i->sibIndex()) + (Bit16s) i->displ16u();
 187   Bit32u laddr;
 188
 189   unsigned s = i->seg();
 190   bx_segment_reg_t *seg = &BX_CPU_THIS_PTR sregs[s];
 191   BX_INSTR_MEM_DATA_ACCESS(BX_CPU_ID, s, offset, 2, BX_READ);
 192
 193   BX_ASSERT(BX_CPU_THIS_PTR cpu_mode != BX_MODE_LONG_64);
 194
 195   if (seg->cache.valid & SegAccessROK) {
 196     if (offset < seg->cache.u.segment.limit_scaled) {
 197 accessOK:
 198       laddr = BX_CPU_THIS_PTR get_laddr32(s, offset);
 199       unsigned tlbIndex = BX_TLB_INDEX_OF(laddr, 1);
 200       Bit32u lpf = LPFOf(laddr);
 201       bx_TLB_entry *tlbEntry = &BX_CPU_THIS_PTR TLB.entry[tlbIndex];
 202       if (tlbEntry->lpf == lpf && ! (tlbEntry->accessBits & USER_PL)) {
 203         // See if the TLB entry privilege level allows us read access
 204         // from this CPL.
 205         bx_hostpageaddr_t hostPageAddr = tlbEntry->hostPageAddr;
 206         Bit32u pageOffset = PAGE_OFFSET(laddr);
 207         Bit16u *hostAddr = (Bit16u*) (hostPageAddr | pageOffset);
 208         ReadHostWordFromLittleEndian(hostAddr, TMP16);
 209         BX_INSTR_LIN_ACCESS(BX_CPU_ID, laddr, tlbEntry->ppf | pageOffset, 2, BX_READ);
 210         BX_DBG_LIN_MEMORY_ACCESS(BX_CPU_ID, laddr,
 211               tlbEntry->ppf | pageOffset, 2, CPL, BX_READ, (Bit8u*) &TMP16);
 212       }
 213       else {
 214         access_read_linear(laddr, 2, CPL, BX_READ, (void *) &TMP16);
 215       }
 216
 217       BX_CPU_CALL_METHOD(i->execute2, (i));
 218       return;
 219     }
 220     else {
 221       BX_ERROR(("LOAD_Ew(): segment limit violation"));
 222       exception(int_number(s), 0, 0);
 223     }
 224   }
 225
 226   if (!read_virtual_checks(seg, offset, 2))
 227     exception(int_number(s), 0, 0);
 228   goto accessOK;
 229 }
 230
 231 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LOAD_Ew_Resolve32Base(bxInstruction_c *i)
 232 {
 233   Bit32u offset = BX_READ_32BIT_REG(i->sibBase()) + (Bit32s) i->displ32u();
 234   Bit32u laddr;
 235
 236   unsigned s = i->seg();
 237   bx_segment_reg_t *seg = &BX_CPU_THIS_PTR sregs[s];
 238   BX_INSTR_MEM_DATA_ACCESS(BX_CPU_ID, s, offset, 2, BX_READ);
 239
 240   BX_ASSERT(BX_CPU_THIS_PTR cpu_mode != BX_MODE_LONG_64);
 241
 242   if (seg->cache.valid & SegAccessROK) {
 243     if (offset < seg->cache.u.segment.limit_scaled) {
 244 accessOK:
 245       laddr = BX_CPU_THIS_PTR get_laddr32(s, offset);
 246       unsigned tlbIndex = BX_TLB_INDEX_OF(laddr, 1);
 247       Bit32u lpf = LPFOf(laddr);
 248       bx_TLB_entry *tlbEntry = &BX_CPU_THIS_PTR TLB.entry[tlbIndex];
 249       if (tlbEntry->lpf == lpf && ! (tlbEntry->accessBits & USER_PL)) {
 250         // See if the TLB entry privilege level allows us read access
 251         // from this CPL.
 252         bx_hostpageaddr_t hostPageAddr = tlbEntry->hostPageAddr;
 253         Bit32u pageOffset = PAGE_OFFSET(laddr);
 254         Bit16u *hostAddr = (Bit16u*) (hostPageAddr | pageOffset);
 255         ReadHostWordFromLittleEndian(hostAddr, TMP16);
 256         BX_INSTR_LIN_ACCESS(BX_CPU_ID, laddr, tlbEntry->ppf | pageOffset, 2, BX_READ);
 257         BX_DBG_LIN_MEMORY_ACCESS(BX_CPU_ID, laddr,
 258               tlbEntry->ppf | pageOffset, 2, CPL, BX_READ, (Bit8u*) &TMP16);
 259       }
 260       else {
 261         access_read_linear(laddr, 2, CPL, BX_READ, (void *) &TMP16);
 262       }
 263
 264       BX_CPU_CALL_METHOD(i->execute2, (i));
 265       return;
 266     }
 267     else {
 268       BX_ERROR(("LOAD_Ew(): segment limit violation"));
 269       exception(int_number(s), 0, 0);
 270     }
 271   }
 272
 273   if (!read_virtual_checks(seg, offset, 2))
 274     exception(int_number(s), 0, 0);
 275   goto accessOK;
 276 }
 277
 278 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LOAD_Ew_Resolve32BaseIndex(bxInstruction_c *i)
 279 {
 280   Bit32u offset = BX_READ_32BIT_REG(i->sibBase()) + (BX_READ_32BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
 281   Bit32u laddr;
 282
 283   unsigned s = i->seg();
 284   bx_segment_reg_t *seg = &BX_CPU_THIS_PTR sregs[s];
 285   BX_INSTR_MEM_DATA_ACCESS(BX_CPU_ID, s, offset, 2, BX_READ);
 286
 287   BX_ASSERT(BX_CPU_THIS_PTR cpu_mode != BX_MODE_LONG_64);
 288
 289   if (seg->cache.valid & SegAccessROK) {
 290     if (offset < seg->cache.u.segment.limit_scaled) {
 291 accessOK:
 292       laddr = BX_CPU_THIS_PTR get_laddr32(s, offset);
 293       unsigned tlbIndex = BX_TLB_INDEX_OF(laddr, 1);
 294       Bit32u lpf = LPFOf(laddr);
 295       bx_TLB_entry *tlbEntry = &BX_CPU_THIS_PTR TLB.entry[tlbIndex];
 296       if (tlbEntry->lpf == lpf && ! (tlbEntry->accessBits & USER_PL)) {
 297         // See if the TLB entry privilege level allows us read access
 298         // from this CPL.
 299         bx_hostpageaddr_t hostPageAddr = tlbEntry->hostPageAddr;
 300         Bit32u pageOffset = PAGE_OFFSET(laddr);
 301         Bit16u *hostAddr = (Bit16u*) (hostPageAddr | pageOffset);
 302         ReadHostWordFromLittleEndian(hostAddr, TMP16);
 303         BX_INSTR_LIN_ACCESS(BX_CPU_ID, laddr, tlbEntry->ppf | pageOffset, 2, BX_READ);
 304         BX_DBG_LIN_MEMORY_ACCESS(BX_CPU_ID, laddr,
 305               tlbEntry->ppf | pageOffset, 2, CPL, BX_READ, (Bit8u*) &TMP16);
 306       }
 307       else {
 308         access_read_linear(laddr, 2, CPL, BX_READ, (void *) &TMP16);
 309       }
 310
 311       BX_CPU_CALL_METHOD(i->execute2, (i));
 312       return;
 313     }
 314     else {
 315       BX_ERROR(("LOAD_Ew(): segment limit violation"));
 316       exception(int_number(s), 0, 0);
 317     }
 318   }
 319
 320   if (!read_virtual_checks(seg, offset, 2))
 321     exception(int_number(s), 0, 0);
 322   goto accessOK;
 323 }
 324
 325 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LOAD_Ed(bxInstruction_c *i)
 326 {
 327   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 328   TMP32 = read_virtual_dword(i->seg(), eaddr);
 329   BX_CPU_CALL_METHOD(i->execute2, (i));
 330 }
 331
 332 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LOAD_Ed_Resolve16BaseIndex(bxInstruction_c *i)
 333 {
 334   Bit16u offset = BX_READ_16BIT_REG(i->sibBase()) + BX_READ_16BIT_REG(i->sibIndex()) + (Bit16s) i->displ16u();
 335   Bit32u laddr;
 336
 337   unsigned s = i->seg();
 338   bx_segment_reg_t *seg = &BX_CPU_THIS_PTR sregs[s];
 339   BX_INSTR_MEM_DATA_ACCESS(BX_CPU_ID, s, offset, 4, BX_READ);
 340
 341   BX_ASSERT(BX_CPU_THIS_PTR cpu_mode != BX_MODE_LONG_64);
 342
 343   if (seg->cache.valid & SegAccessROK) {
 344     if (offset < (seg->cache.u.segment.limit_scaled-2)) {
 345 accessOK:
 346       laddr = BX_CPU_THIS_PTR get_laddr32(s, offset);
 347       unsigned tlbIndex = BX_TLB_INDEX_OF(laddr, 3);
 348       Bit32u lpf = LPFOf(laddr);
 349       bx_TLB_entry *tlbEntry = &BX_CPU_THIS_PTR TLB.entry[tlbIndex];
 350       if (tlbEntry->lpf == lpf && ! (tlbEntry->accessBits & USER_PL)) {
 351         // See if the TLB entry privilege level allows us read access
 352         // from this CPL.
 353         bx_hostpageaddr_t hostPageAddr = tlbEntry->hostPageAddr;
 354         Bit32u pageOffset = PAGE_OFFSET(laddr);
 355         Bit32u *hostAddr = (Bit32u*) (hostPageAddr | pageOffset);
 356         ReadHostDWordFromLittleEndian(hostAddr, TMP32);
 357         BX_INSTR_LIN_ACCESS(BX_CPU_ID, laddr, tlbEntry->ppf | pageOffset, 4, BX_READ);
 358         BX_DBG_LIN_MEMORY_ACCESS(BX_CPU_ID, laddr,
 359               tlbEntry->ppf | pageOffset, 4, CPL, BX_READ, (Bit8u*) &TMP32);
 360       }
 361       else {
 362         access_read_linear(laddr, 4, CPL, BX_READ, (void *) &TMP32);
 363       }
 364
 365       BX_CPU_CALL_METHOD(i->execute2, (i));
 366       return;
 367     }
 368     else {
 369       BX_ERROR(("LOAD_Ed(): segment limit violation"));
 370       exception(int_number(s), 0, 0);
 371     }
 372   }
 373
 374   if (!read_virtual_checks(seg, offset, 4))
 375     exception(int_number(s), 0, 0);
 376   goto accessOK;
 377 }
 378
 379 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LOAD_Ed_Resolve32Base(bxInstruction_c *i)
 380 {
 381   Bit32u offset = BX_READ_32BIT_REG(i->sibBase()) + (Bit32s) i->displ32u();
 382   Bit32u laddr;
 383
 384   unsigned s = i->seg();
 385   bx_segment_reg_t *seg = &BX_CPU_THIS_PTR sregs[s];
 386   BX_INSTR_MEM_DATA_ACCESS(BX_CPU_ID, s, offset, 4, BX_READ);
 387
 388   BX_ASSERT(BX_CPU_THIS_PTR cpu_mode != BX_MODE_LONG_64);
 389
 390   if (seg->cache.valid & SegAccessROK) {
 391     if (offset < (seg->cache.u.segment.limit_scaled-2)) {
 392 accessOK:
 393       laddr = BX_CPU_THIS_PTR get_laddr32(s, offset);
 394       unsigned tlbIndex = BX_TLB_INDEX_OF(laddr, 3);
 395       Bit32u lpf = LPFOf(laddr);
 396       bx_TLB_entry *tlbEntry = &BX_CPU_THIS_PTR TLB.entry[tlbIndex];
 397       if (tlbEntry->lpf == lpf && ! (tlbEntry->accessBits & USER_PL)) {
 398         // See if the TLB entry privilege level allows us read access
 399         // from this CPL.
 400         bx_hostpageaddr_t hostPageAddr = tlbEntry->hostPageAddr;
 401         Bit32u pageOffset = PAGE_OFFSET(laddr);
 402         Bit32u *hostAddr = (Bit32u*) (hostPageAddr | pageOffset);
 403         ReadHostDWordFromLittleEndian(hostAddr, TMP32);
 404         BX_INSTR_LIN_ACCESS(BX_CPU_ID, laddr, tlbEntry->ppf | pageOffset, 4, BX_READ);
 405         BX_DBG_LIN_MEMORY_ACCESS(BX_CPU_ID, laddr,
 406             tlbEntry->ppf | pageOffset, 4, CPL, BX_READ, (Bit8u*) &TMP32);
 407       }
 408       else {
 409         access_read_linear(laddr, 4, CPL, BX_READ, (void *) &TMP32);
 410       }
 411
 412       BX_CPU_CALL_METHOD(i->execute2, (i));
 413       return;
 414     }
 415     else {
 416       BX_ERROR(("LOAD_Ed(): segment limit violation"));
 417       exception(int_number(s), 0, 0);
 418     }
 419   }
 420
 421   if (!read_virtual_checks(seg, offset, 4))
 422     exception(int_number(s), 0, 0);
 423   goto accessOK;
 424 }
 425
 426 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LOAD_Ed_Resolve32BaseIndex(bxInstruction_c *i)
 427 {
 428   Bit32u offset = BX_READ_32BIT_REG(i->sibBase()) + (BX_READ_32BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
 429   Bit32u laddr;
 430
 431   unsigned s = i->seg();
 432   bx_segment_reg_t *seg = &BX_CPU_THIS_PTR sregs[s];
 433   BX_INSTR_MEM_DATA_ACCESS(BX_CPU_ID, s, offset, 4, BX_READ);
 434
 435   BX_ASSERT(BX_CPU_THIS_PTR cpu_mode != BX_MODE_LONG_64);
 436
 437   if (seg->cache.valid & SegAccessROK) {
 438     if (offset < (seg->cache.u.segment.limit_scaled-2)) {
 439 accessOK:
 440       laddr = BX_CPU_THIS_PTR get_laddr32(s, offset);
 441       unsigned tlbIndex = BX_TLB_INDEX_OF(laddr, 3);
 442       Bit32u lpf = LPFOf(laddr);
 443       bx_TLB_entry *tlbEntry = &BX_CPU_THIS_PTR TLB.entry[tlbIndex];
 444       if (tlbEntry->lpf == lpf && !(tlbEntry->accessBits & USER_PL)) {
 445         // See if the TLB entry privilege level allows us read access
 446         // from this CPL.
 447         bx_hostpageaddr_t hostPageAddr = tlbEntry->hostPageAddr;
 448         Bit32u pageOffset = PAGE_OFFSET(laddr);
 449         Bit32u *hostAddr = (Bit32u*) (hostPageAddr | pageOffset);
 450         ReadHostDWordFromLittleEndian(hostAddr, TMP32);
 451         BX_INSTR_LIN_ACCESS(BX_CPU_ID, laddr, tlbEntry->ppf | pageOffset, 4, BX_READ);
 452         BX_DBG_LIN_MEMORY_ACCESS(BX_CPU_ID, laddr,
 453               tlbEntry->ppf | pageOffset, 4, CPL, BX_READ, (Bit8u*) &TMP32);
 454       }
 455       else {
 456         access_read_linear(laddr, 4, CPL, BX_READ, (void *) &TMP32);
 457       }
 458
 459       BX_CPU_CALL_METHOD(i->execute2, (i));
 460       return;
 461     }
 462     else {
 463       BX_ERROR(("LOAD_Ed(): segment limit violation"));
 464       exception(int_number(s), 0, 0);
 465     }
 466   }
 467
 468   if (!read_virtual_checks(seg, offset, 4))
 469     exception(int_number(s), 0, 0);
 470   goto accessOK;
 471 }
 472
 473 #if BX_SUPPORT_X86_64
 474 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LOAD_Eq(bxInstruction_c *i)
 475 {
 476   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 477   TMP64 = read_virtual_qword_64(i->seg(), eaddr);
 478   BX_CPU_CALL_METHOD(i->execute2, (i));
 479 }
 480 #endif
 481
 482 #if BX_SUPPORT_SSE >= 1
 483
 484 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LOAD_Wdq(bxInstruction_c *i)
 485 {
 486   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 487   readVirtualDQwordAligned(i->seg(), eaddr, (Bit8u *)(&BX_READ_XMM_REG(BX_TMP_REGISTER)));
 488   BX_CPU_CALL_METHOD(i->execute2, (i));
 489 }
 490
 491 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LOAD_Wss(bxInstruction_c *i)
 492 {
 493   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 494   Bit32u val_32 = read_virtual_dword(i->seg(), eaddr);
 495   BX_WRITE_XMM_REG_LO_DWORD(BX_TMP_REGISTER, val_32);
 496   BX_CPU_CALL_METHOD(i->execute2, (i));
 497 }
 498
 499 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LOAD_Wsd(bxInstruction_c *i)
 500 {
 501   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 502   Bit64u val_64 = read_virtual_qword(i->seg(), eaddr);
 503   BX_WRITE_XMM_REG_LO_QWORD(BX_TMP_REGISTER, val_64);
 504   BX_CPU_CALL_METHOD(i->execute2, (i));
 505 }
 506
 507 #endif
 508