cpu/resolve64.cc

   1 /////////////////////////////////////////////////////////////////////////
   2 // $Id: resolve64.cc,v 1.10 2007/04/09 21:15:00 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
  34 #if BX_SUPPORT_X86_64
  35
  36   void  BX_CPP_AttrRegparmN(1)
  37 BX_CPU_C::Resolve64Mod0Rm0(bxInstruction_c *i)
  38 {
  39   RMAddr(i) = RAX;
  40 }
  41   void  BX_CPP_AttrRegparmN(1)
  42 BX_CPU_C::Resolve64Mod0Rm1(bxInstruction_c *i)
  43 {
  44   RMAddr(i) = RCX;
  45 }
  46   void  BX_CPP_AttrRegparmN(1)
  47 BX_CPU_C::Resolve64Mod0Rm2(bxInstruction_c *i)
  48 {
  49   RMAddr(i) = RDX;
  50 }
  51   void  BX_CPP_AttrRegparmN(1)
  52 BX_CPU_C::Resolve64Mod0Rm3(bxInstruction_c *i)
  53 {
  54   RMAddr(i) = RBX;
  55 }
  56   void  BX_CPP_AttrRegparmN(1)
  57 BX_CPU_C::Resolve64Mod0Rip(bxInstruction_c *i)
  58 {
  59   // RIP hasn't been bumped yet when this is called.  must choose the saved value.
  60   RMAddr(i) = BX_CPU_THIS_PTR prev_eip + i->ilen() + (Bit32s)i->displ32u();
  61 }
  62   void  BX_CPP_AttrRegparmN(1)
  63 BX_CPU_C::Resolve64Mod0Rm6(bxInstruction_c *i)
  64 {
  65   RMAddr(i) = RSI;
  66 }
  67   void  BX_CPP_AttrRegparmN(1)
  68 BX_CPU_C::Resolve64Mod0Rm7(bxInstruction_c *i)
  69 {
  70   RMAddr(i) = RDI;
  71 }
  72   void  BX_CPP_AttrRegparmN(1)
  73 BX_CPU_C::Resolve64Mod0Rm8(bxInstruction_c *i)
  74 {
  75   RMAddr(i) = R8;
  76 }
  77   void  BX_CPP_AttrRegparmN(1)
  78 BX_CPU_C::Resolve64Mod0Rm9(bxInstruction_c *i)
  79 {
  80   RMAddr(i) = R9;
  81 }
  82   void  BX_CPP_AttrRegparmN(1)
  83 BX_CPU_C::Resolve64Mod0Rm10(bxInstruction_c *i)
  84 {
  85   RMAddr(i) = R10;
  86 }
  87   void  BX_CPP_AttrRegparmN(1)
  88 BX_CPU_C::Resolve64Mod0Rm11(bxInstruction_c *i)
  89 {
  90   RMAddr(i) = R11;
  91 }
  92   void  BX_CPP_AttrRegparmN(1)
  93 BX_CPU_C::Resolve64Mod0Rm14(bxInstruction_c *i)
  94 {
  95   RMAddr(i) = R14;
  96 }
  97   void  BX_CPP_AttrRegparmN(1)
  98 BX_CPU_C::Resolve64Mod0Rm15(bxInstruction_c *i)
  99 {
 100   RMAddr(i) = R15;
 101 }
 102
 103
 104   void  BX_CPP_AttrRegparmN(1)
 105 BX_CPU_C::Resolve64Mod1or2Rm0(bxInstruction_c *i)
 106 {
 107   RMAddr(i) = RAX + (Bit32s) i->displ32u();
 108 }
 109   void  BX_CPP_AttrRegparmN(1)
 110 BX_CPU_C::Resolve64Mod1or2Rm1(bxInstruction_c *i)
 111 {
 112   RMAddr(i) = RCX + (Bit32s) i->displ32u();
 113 }
 114   void  BX_CPP_AttrRegparmN(1)
 115 BX_CPU_C::Resolve64Mod1or2Rm2(bxInstruction_c *i)
 116 {
 117   RMAddr(i) = RDX + (Bit32s) i->displ32u();
 118 }
 119   void  BX_CPP_AttrRegparmN(1)
 120 BX_CPU_C::Resolve64Mod1or2Rm3(bxInstruction_c *i)
 121 {
 122   RMAddr(i) = RBX + (Bit32s) i->displ32u();
 123 }
 124   void  BX_CPP_AttrRegparmN(1)
 125 BX_CPU_C::Resolve64Mod1or2Rm5(bxInstruction_c *i)
 126 {
 127   RMAddr(i) = RBP + (Bit32s) i->displ32u();
 128 }
 129   void  BX_CPP_AttrRegparmN(1)
 130 BX_CPU_C::Resolve64Mod1or2Rm6(bxInstruction_c *i)
 131 {
 132   RMAddr(i) = RSI + (Bit32s) i->displ32u();
 133 }
 134   void  BX_CPP_AttrRegparmN(1)
 135 BX_CPU_C::Resolve64Mod1or2Rm7(bxInstruction_c *i)
 136 {
 137   RMAddr(i) = RDI + (Bit32s) i->displ32u();
 138 }
 139   void  BX_CPP_AttrRegparmN(1)
 140 BX_CPU_C::Resolve64Mod1or2Rm8(bxInstruction_c *i)
 141 {
 142   RMAddr(i) = R8 + (Bit32s) i->displ32u();
 143 }
 144   void  BX_CPP_AttrRegparmN(1)
 145 BX_CPU_C::Resolve64Mod1or2Rm9(bxInstruction_c *i)
 146 {
 147   RMAddr(i) = R9 + (Bit32s) i->displ32u();
 148 }
 149   void  BX_CPP_AttrRegparmN(1)
 150 BX_CPU_C::Resolve64Mod1or2Rm10(bxInstruction_c *i)
 151 {
 152   RMAddr(i) = R10 + (Bit32s) i->displ32u();
 153 }
 154   void  BX_CPP_AttrRegparmN(1)
 155 BX_CPU_C::Resolve64Mod1or2Rm11(bxInstruction_c *i)
 156 {
 157   RMAddr(i) = R11 + (Bit32s) i->displ32u();
 158 }
 159   void  BX_CPP_AttrRegparmN(1)
 160 BX_CPU_C::Resolve64Mod1or2Rm13(bxInstruction_c *i)
 161 {
 162   RMAddr(i) = R13 + (Bit32s) i->displ32u();
 163 }
 164   void  BX_CPP_AttrRegparmN(1)
 165 BX_CPU_C::Resolve64Mod1or2Rm14(bxInstruction_c *i)
 166 {
 167   RMAddr(i) = R14 + (Bit32s) i->displ32u();
 168 }
 169   void  BX_CPP_AttrRegparmN(1)
 170 BX_CPU_C::Resolve64Mod1or2Rm15(bxInstruction_c *i)
 171 {
 172   RMAddr(i) = R15 + (Bit32s) i->displ32u();
 173 }
 174
 175
 176   void  BX_CPP_AttrRegparmN(1)
 177 BX_CPU_C::Resolve64Mod0Base0(bxInstruction_c *i)
 178 {
 179   if (i->sibIndex() != 4)
 180     RMAddr(i) = RAX + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
 181   else
 182     RMAddr(i) = RAX;
 183 }
 184   void  BX_CPP_AttrRegparmN(1)
 185 BX_CPU_C::Resolve64Mod0Base1(bxInstruction_c *i)
 186 {
 187   if (i->sibIndex() != 4)
 188     RMAddr(i) = RCX + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
 189   else
 190     RMAddr(i) = RCX;
 191 }
 192   void  BX_CPP_AttrRegparmN(1)
 193 BX_CPU_C::Resolve64Mod0Base2(bxInstruction_c *i)
 194 {
 195   if (i->sibIndex() != 4)
 196     RMAddr(i) = RDX + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
 197   else
 198     RMAddr(i) = RDX;
 199 }
 200   void  BX_CPP_AttrRegparmN(1)
 201 BX_CPU_C::Resolve64Mod0Base3(bxInstruction_c *i)
 202 {
 203   if (i->sibIndex() != 4)
 204     RMAddr(i) = RBX + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
 205   else
 206     RMAddr(i) = RBX;
 207 }
 208   void  BX_CPP_AttrRegparmN(1)
 209 BX_CPU_C::Resolve64Mod0Base4(bxInstruction_c *i)
 210 {
 211   if (i->sibIndex() != 4)
 212     RMAddr(i) = RSP + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
 213   else
 214     RMAddr(i) = RSP;
 215 }
 216   void  BX_CPP_AttrRegparmN(1)
 217 BX_CPU_C::Resolve64Mod0Base5(bxInstruction_c *i)
 218 {
 219   if (i->sibIndex() != 4)
 220     RMAddr(i) = (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
 221   else
 222     RMAddr(i) = (Bit32s) i->displ32u();
 223 }
 224   void  BX_CPP_AttrRegparmN(1)
 225 BX_CPU_C::Resolve64Mod0Base6(bxInstruction_c *i)
 226 {
 227   if (i->sibIndex() != 4)
 228     RMAddr(i) = RSI + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
 229   else
 230     RMAddr(i) = RSI;
 231 }
 232   void  BX_CPP_AttrRegparmN(1)
 233 BX_CPU_C::Resolve64Mod0Base7(bxInstruction_c *i)
 234 {
 235   if (i->sibIndex() != 4)
 236     RMAddr(i) = RDI + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
 237   else
 238     RMAddr(i) = RDI;
 239 }
 240   void  BX_CPP_AttrRegparmN(1)
 241 BX_CPU_C::Resolve64Mod0Base8(bxInstruction_c *i)
 242 {
 243   if (i->sibIndex() != 4)
 244     RMAddr(i) = R8 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
 245   else
 246     RMAddr(i) = R8;
 247 }
 248   void  BX_CPP_AttrRegparmN(1)
 249 BX_CPU_C::Resolve64Mod0Base9(bxInstruction_c *i)
 250 {
 251   if (i->sibIndex() != 4)
 252     RMAddr(i) = R9 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
 253   else
 254     RMAddr(i) = R9;
 255 }
 256   void  BX_CPP_AttrRegparmN(1)
 257 BX_CPU_C::Resolve64Mod0Base10(bxInstruction_c *i)
 258 {
 259   if (i->sibIndex() != 4)
 260     RMAddr(i) = R10 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
 261   else
 262     RMAddr(i) = R10;
 263 }
 264   void  BX_CPP_AttrRegparmN(1)
 265 BX_CPU_C::Resolve64Mod0Base11(bxInstruction_c *i)
 266 {
 267   if (i->sibIndex() != 4)
 268     RMAddr(i) = R11 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
 269   else
 270     RMAddr(i) = R11;
 271 }
 272   void  BX_CPP_AttrRegparmN(1)
 273 BX_CPU_C::Resolve64Mod0Base12(bxInstruction_c *i)
 274 {
 275   if (i->sibIndex() != 4)
 276     RMAddr(i) = R12 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
 277   else
 278     RMAddr(i) = R12;
 279 }
 280   void  BX_CPP_AttrRegparmN(1)
 281 BX_CPU_C::Resolve64Mod0Base13(bxInstruction_c *i)
 282 {
 283   if (i->sibIndex() != 4)
 284     RMAddr(i) = R13 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
 285   else
 286     RMAddr(i) = R13;
 287 }
 288   void  BX_CPP_AttrRegparmN(1)
 289 BX_CPU_C::Resolve64Mod0Base14(bxInstruction_c *i)
 290 {
 291   if (i->sibIndex() != 4)
 292     RMAddr(i) = R14 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
 293   else
 294     RMAddr(i) = R14;
 295 }
 296   void  BX_CPP_AttrRegparmN(1)
 297 BX_CPU_C::Resolve64Mod0Base15(bxInstruction_c *i)
 298 {
 299   if (i->sibIndex() != 4)
 300     RMAddr(i) = R15 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale());
 301   else
 302     RMAddr(i) = R15;
 303 }
 304
 305   void  BX_CPP_AttrRegparmN(1)
 306 BX_CPU_C::Resolve64Mod1or2Base0(bxInstruction_c *i)
 307 {
 308   if (i->sibIndex() != 4)
 309     RMAddr(i) = RAX + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
 310   else
 311     RMAddr(i) = RAX + (Bit32s) i->displ32u();
 312 }
 313   void  BX_CPP_AttrRegparmN(1)
 314 BX_CPU_C::Resolve64Mod1or2Base1(bxInstruction_c *i)
 315 {
 316   if (i->sibIndex() != 4)
 317     RMAddr(i) = RCX + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
 318   else
 319     RMAddr(i) = RCX + (Bit32s) i->displ32u();
 320 }
 321   void  BX_CPP_AttrRegparmN(1)
 322 BX_CPU_C::Resolve64Mod1or2Base2(bxInstruction_c *i)
 323 {
 324   if (i->sibIndex() != 4)
 325     RMAddr(i) = RDX + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
 326   else
 327     RMAddr(i) = RDX + (Bit32s) i->displ32u();
 328 }
 329   void  BX_CPP_AttrRegparmN(1)
 330 BX_CPU_C::Resolve64Mod1or2Base3(bxInstruction_c *i)
 331 {
 332   if (i->sibIndex() != 4)
 333     RMAddr(i) = RBX + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
 334   else
 335     RMAddr(i) = RBX + (Bit32s) i->displ32u();
 336 }
 337   void  BX_CPP_AttrRegparmN(1)
 338 BX_CPU_C::Resolve64Mod1or2Base4(bxInstruction_c *i)
 339 {
 340   if (i->sibIndex() != 4)
 341     RMAddr(i) = RSP + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
 342   else
 343     RMAddr(i) = RSP + (Bit32s) i->displ32u();
 344 }
 345   void  BX_CPP_AttrRegparmN(1)
 346 BX_CPU_C::Resolve64Mod1or2Base5(bxInstruction_c *i)
 347 {
 348   if (i->sibIndex() != 4)
 349     RMAddr(i) = RBP + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
 350   else
 351     RMAddr(i) = RBP + (Bit32s) i->displ32u();
 352 }
 353   void  BX_CPP_AttrRegparmN(1)
 354 BX_CPU_C::Resolve64Mod1or2Base6(bxInstruction_c *i)
 355 {
 356   if (i->sibIndex() != 4)
 357     RMAddr(i) = RSI + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
 358   else
 359     RMAddr(i) = RSI + (Bit32s) i->displ32u();
 360 }
 361   void  BX_CPP_AttrRegparmN(1)
 362 BX_CPU_C::Resolve64Mod1or2Base7(bxInstruction_c *i)
 363 {
 364   if (i->sibIndex() != 4)
 365     RMAddr(i) = RDI + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
 366   else
 367     RMAddr(i) = RDI + (Bit32s) i->displ32u();
 368 }
 369   void  BX_CPP_AttrRegparmN(1)
 370 BX_CPU_C::Resolve64Mod1or2Base8(bxInstruction_c *i)
 371 {
 372   if (i->sibIndex() != 4)
 373     RMAddr(i) = R8 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
 374   else
 375     RMAddr(i) = R8 + (Bit32s) i->displ32u();
 376 }
 377   void  BX_CPP_AttrRegparmN(1)
 378 BX_CPU_C::Resolve64Mod1or2Base9(bxInstruction_c *i)
 379 {
 380   if (i->sibIndex() != 4)
 381     RMAddr(i) = R9 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
 382   else
 383     RMAddr(i) = R9 + (Bit32s) i->displ32u();
 384 }
 385   void  BX_CPP_AttrRegparmN(1)
 386 BX_CPU_C::Resolve64Mod1or2Base10(bxInstruction_c *i)
 387 {
 388   if (i->sibIndex() != 4)
 389     RMAddr(i) = R10 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
 390   else
 391     RMAddr(i) = R10 + (Bit32s) i->displ32u();
 392 }
 393   void  BX_CPP_AttrRegparmN(1)
 394 BX_CPU_C::Resolve64Mod1or2Base11(bxInstruction_c *i)
 395 {
 396   if (i->sibIndex() != 4)
 397     RMAddr(i) = R11 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
 398   else
 399     RMAddr(i) = R11 + (Bit32s) i->displ32u();
 400 }
 401   void  BX_CPP_AttrRegparmN(1)
 402 BX_CPU_C::Resolve64Mod1or2Base12(bxInstruction_c *i)
 403 {
 404   if (i->sibIndex() != 4)
 405     RMAddr(i) = R12 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
 406   else
 407     RMAddr(i) = R12 + (Bit32s) i->displ32u();
 408 }
 409   void  BX_CPP_AttrRegparmN(1)
 410 BX_CPU_C::Resolve64Mod1or2Base13(bxInstruction_c *i)
 411 {
 412   if (i->sibIndex() != 4)
 413     RMAddr(i) = R13 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
 414   else
 415     RMAddr(i) = R13 + (Bit32s) i->displ32u();
 416 }
 417   void  BX_CPP_AttrRegparmN(1)
 418 BX_CPU_C::Resolve64Mod1or2Base14(bxInstruction_c *i)
 419 {
 420   if (i->sibIndex() != 4)
 421     RMAddr(i) = R14 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
 422   else
 423     RMAddr(i) = R14 + (Bit32s) i->displ32u();
 424 }
 425   void  BX_CPP_AttrRegparmN(1)
 426 BX_CPU_C::Resolve64Mod1or2Base15(bxInstruction_c *i)
 427 {
 428   if (i->sibIndex() != 4)
 429     RMAddr(i) = R15 + (BX_READ_64BIT_REG(i->sibIndex()) << i->sibScale()) + (Bit32s) i->displ32u();
 430   else
 431     RMAddr(i) = R15 + (Bit32s) i->displ32u();
 432 }
 433
 434 #endif /* if BX_SUPPORT_X86_64 */