cpu/ctrl_xfer64.cc

   1 ////////c/////////////////////////////////////////////////////////////////
   2 // $Id: ctrl_xfer64.cc,v 1.75 2008/12/01 19:06:14 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_SUPPORT_X86_64
  34
  35 BX_CPP_INLINE void BX_CPP_AttrRegparmN(1) BX_CPU_C::branch_near64(bxInstruction_c *i)
  36 {
  37   Bit64u new_RIP = RIP + (Bit32s) i->Id();
  38
  39   if (! IsCanonical(new_RIP)) {
  40     BX_ERROR(("branch_near64: canonical RIP violation"));
  41     exception(BX_GP_EXCEPTION, 0, 0);
  42   }
  43
  44   RIP = new_RIP;
  45
  46 #if BX_SUPPORT_TRACE_CACHE && !defined(BX_TRACE_CACHE_NO_SPECULATIVE_TRACING)
  47   // assert magic async_event to stop trace execution
  48   BX_CPU_THIS_PTR async_event |= BX_ASYNC_EVENT_STOP_TRACE;
  49 #endif
  50 }
  51
  52 void BX_CPP_AttrRegparmN(1) BX_CPU_C::RETnear64_Iw(bxInstruction_c *i)
  53 {
  54 #if BX_DEBUGGER
  55   BX_CPU_THIS_PTR show_flag |= Flag_ret;
  56 #endif
  57
  58   Bit64u return_RIP = read_virtual_qword_64(BX_SEG_REG_SS, RSP);
  59
  60   if (! IsCanonical(return_RIP)) {
  61     BX_ERROR(("RETnear64_Iw: canonical RIP violation"));
  62     exception(BX_GP_EXCEPTION, 0, 0);
  63   }
  64
  65   RIP = return_RIP;
  66   RSP += 8 + i->Iw();
  67
  68   BX_INSTR_UCNEAR_BRANCH(BX_CPU_ID, BX_INSTR_IS_RET, RIP);
  69 }
  70
  71 void BX_CPP_AttrRegparmN(1) BX_CPU_C::RETnear64(bxInstruction_c *i)
  72 {
  73 #if BX_DEBUGGER
  74   BX_CPU_THIS_PTR show_flag |= Flag_ret;
  75 #endif
  76
  77   Bit64u return_RIP = read_virtual_qword_64(BX_SEG_REG_SS, RSP);
  78
  79   if (! IsCanonical(return_RIP)) {
  80     BX_ERROR(("RETnear64: canonical RIP violation %08x%08x", GET32H(return_RIP), GET32L(return_RIP)));
  81     exception(BX_GP_EXCEPTION, 0, 0);
  82   }
  83
  84   RIP = return_RIP;
  85   RSP += 8;
  86
  87   BX_INSTR_UCNEAR_BRANCH(BX_CPU_ID, BX_INSTR_IS_RET, RIP);
  88 }
  89
  90 void BX_CPP_AttrRegparmN(1) BX_CPU_C::RETfar64_Iw(bxInstruction_c *i)
  91 {
  92   invalidate_prefetch_q();
  93
  94 #if BX_DEBUGGER
  95   BX_CPU_THIS_PTR show_flag |= Flag_ret;
  96 #endif
  97
  98   BX_ASSERT(protected_mode());
  99
 100   BX_CPU_THIS_PTR speculative_rsp = 1;
 101   BX_CPU_THIS_PTR prev_rsp = RSP;
 102
 103   // return_protected is not RSP safe
 104   return_protected(i, i->Iw());
 105
 106   BX_CPU_THIS_PTR speculative_rsp = 0;
 107
 108   BX_INSTR_FAR_BRANCH(BX_CPU_ID, BX_INSTR_IS_RET,
 109                       BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.value, RIP);
 110 }
 111
 112 void BX_CPP_AttrRegparmN(1) BX_CPU_C::RETfar64(bxInstruction_c *i)
 113 {
 114   invalidate_prefetch_q();
 115
 116 #if BX_DEBUGGER
 117   BX_CPU_THIS_PTR show_flag |= Flag_ret;
 118 #endif
 119
 120   BX_ASSERT(protected_mode());
 121
 122   BX_CPU_THIS_PTR speculative_rsp = 1;
 123   BX_CPU_THIS_PTR prev_rsp = RSP;
 124
 125   // return_protected is not RSP safe
 126   return_protected(i, 0);
 127
 128   BX_CPU_THIS_PTR speculative_rsp = 0;
 129
 130   BX_INSTR_FAR_BRANCH(BX_CPU_ID, BX_INSTR_IS_RET,
 131                       BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.value, RIP);
 132 }
 133
 134 void BX_CPP_AttrRegparmN(1) BX_CPU_C::CALL_Jq(bxInstruction_c *i)
 135 {
 136   Bit64u new_RIP = RIP + (Bit32s) i->Id();
 137
 138 #if BX_DEBUGGER
 139   BX_CPU_THIS_PTR show_flag |= Flag_call;
 140 #endif
 141
 142   /* push 64 bit EA of next instruction */
 143   write_virtual_qword_64(BX_SEG_REG_SS, RSP-8, RIP);
 144
 145   if (! IsCanonical(new_RIP)) {
 146     BX_ERROR(("CALL_Jq: canonical RIP violation"));
 147     exception(BX_GP_EXCEPTION, 0, 0);
 148   }
 149
 150   RIP = new_RIP;
 151   RSP -= 8;
 152
 153   BX_INSTR_UCNEAR_BRANCH(BX_CPU_ID, BX_INSTR_IS_CALL, RIP);
 154 }
 155
 156 void BX_CPP_AttrRegparmN(1) BX_CPU_C::CALL_EqR(bxInstruction_c *i)
 157 {
 158 #if BX_DEBUGGER
 159   BX_CPU_THIS_PTR show_flag |= Flag_call;
 160 #endif
 161
 162   Bit64u new_RIP = BX_READ_64BIT_REG(i->rm());
 163
 164   /* push 64 bit EA of next instruction */
 165   write_virtual_qword_64(BX_SEG_REG_SS, RSP-8, RIP);
 166
 167   if (! IsCanonical(new_RIP))
 168   {
 169     BX_ERROR(("CALL_Eq: canonical RIP violation"));
 170     exception(BX_GP_EXCEPTION, 0, 0);
 171   }
 172
 173   RIP = new_RIP;
 174   RSP -= 8;
 175
 176   BX_INSTR_UCNEAR_BRANCH(BX_CPU_ID, BX_INSTR_IS_CALL, RIP);
 177 }
 178
 179 void BX_CPP_AttrRegparmN(1) BX_CPU_C::CALL64_Ep(bxInstruction_c *i)
 180 {
 181   invalidate_prefetch_q();
 182
 183 #if BX_DEBUGGER
 184   BX_CPU_THIS_PTR show_flag |= Flag_call;
 185 #endif
 186
 187   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 188
 189   /* pointer, segment address pair */
 190   Bit64u op1_64 = read_virtual_qword_64(i->seg(), eaddr);
 191   Bit16u cs_raw = read_virtual_word_64(i->seg(), eaddr+8);
 192
 193   BX_ASSERT(protected_mode());
 194
 195   BX_CPU_THIS_PTR speculative_rsp = 1;
 196   BX_CPU_THIS_PTR prev_rsp = RSP;
 197
 198   // call_protected is not RSP safe
 199   call_protected(i, cs_raw, op1_64);
 200
 201   BX_CPU_THIS_PTR speculative_rsp = 0;
 202
 203   BX_INSTR_FAR_BRANCH(BX_CPU_ID, BX_INSTR_IS_CALL,
 204                       BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.value, RIP);
 205 }
 206
 207 void BX_CPP_AttrRegparmN(1) BX_CPU_C::JMP_Jq(bxInstruction_c *i)
 208 {
 209   Bit64u new_RIP = RIP + (Bit32s) i->Id();
 210
 211   if (! IsCanonical(new_RIP)) {
 212     BX_ERROR(("JMP_Jq: canonical RIP violation"));
 213     exception(BX_GP_EXCEPTION, 0, 0);
 214   }
 215
 216   RIP = new_RIP;
 217
 218   BX_INSTR_UCNEAR_BRANCH(BX_CPU_ID, BX_INSTR_IS_JMP, RIP);
 219 }
 220
 221 void BX_CPP_AttrRegparmN(1) BX_CPU_C::JO_Jq(bxInstruction_c *i)
 222 {
 223   if (get_OF()) {
 224     branch_near64(i);
 225     BX_INSTR_CNEAR_BRANCH_TAKEN(BX_CPU_ID, RIP);
 226   }
 227 #if BX_INSTRUMENTATION
 228   else {
 229     BX_INSTR_CNEAR_BRANCH_NOT_TAKEN(BX_CPU_ID);
 230   }
 231 #endif
 232 }
 233
 234 void BX_CPP_AttrRegparmN(1) BX_CPU_C::JNO_Jq(bxInstruction_c *i)
 235 {
 236   if (! get_OF()) {
 237     branch_near64(i);
 238     BX_INSTR_CNEAR_BRANCH_TAKEN(BX_CPU_ID, RIP);
 239   }
 240 #if BX_INSTRUMENTATION
 241   else {
 242     BX_INSTR_CNEAR_BRANCH_NOT_TAKEN(BX_CPU_ID);
 243   }
 244 #endif
 245 }
 246
 247 void BX_CPP_AttrRegparmN(1) BX_CPU_C::JB_Jq(bxInstruction_c *i)
 248 {
 249   if (get_CF()) {
 250     branch_near64(i);
 251     BX_INSTR_CNEAR_BRANCH_TAKEN(BX_CPU_ID, RIP);
 252   }
 253 #if BX_INSTRUMENTATION
 254   else {
 255     BX_INSTR_CNEAR_BRANCH_NOT_TAKEN(BX_CPU_ID);
 256   }
 257 #endif
 258 }
 259
 260 void BX_CPP_AttrRegparmN(1) BX_CPU_C::JNB_Jq(bxInstruction_c *i)
 261 {
 262   if (! get_CF()) {
 263     branch_near64(i);
 264     BX_INSTR_CNEAR_BRANCH_TAKEN(BX_CPU_ID, RIP);
 265   }
 266 #if BX_INSTRUMENTATION
 267   else {
 268     BX_INSTR_CNEAR_BRANCH_NOT_TAKEN(BX_CPU_ID);
 269   }
 270 #endif
 271 }
 272
 273 void BX_CPP_AttrRegparmN(1) BX_CPU_C::JZ_Jq(bxInstruction_c *i)
 274 {
 275   if (get_ZF()) {
 276     branch_near64(i);
 277     BX_INSTR_CNEAR_BRANCH_TAKEN(BX_CPU_ID, RIP);
 278   }
 279 #if BX_INSTRUMENTATION
 280   else {
 281     BX_INSTR_CNEAR_BRANCH_NOT_TAKEN(BX_CPU_ID);
 282   }
 283 #endif
 284 }
 285
 286 void BX_CPP_AttrRegparmN(1) BX_CPU_C::JNZ_Jq(bxInstruction_c *i)
 287 {
 288   if (! get_ZF()) {
 289     branch_near64(i);
 290     BX_INSTR_CNEAR_BRANCH_TAKEN(BX_CPU_ID, RIP);
 291   }
 292 #if BX_INSTRUMENTATION
 293   else {
 294     BX_INSTR_CNEAR_BRANCH_NOT_TAKEN(BX_CPU_ID);
 295   }
 296 #endif
 297 }
 298
 299 void BX_CPP_AttrRegparmN(1) BX_CPU_C::JBE_Jq(bxInstruction_c *i)
 300 {
 301   if (get_CF() || get_ZF()) {
 302     branch_near64(i);
 303     BX_INSTR_CNEAR_BRANCH_TAKEN(BX_CPU_ID, RIP);
 304   }
 305 #if BX_INSTRUMENTATION
 306   else {
 307     BX_INSTR_CNEAR_BRANCH_NOT_TAKEN(BX_CPU_ID);
 308   }
 309 #endif
 310 }
 311
 312 void BX_CPP_AttrRegparmN(1) BX_CPU_C::JNBE_Jq(bxInstruction_c *i)
 313 {
 314   if (! (get_CF() || get_ZF())) {
 315     branch_near64(i);
 316     BX_INSTR_CNEAR_BRANCH_TAKEN(BX_CPU_ID, RIP);
 317   }
 318 #if BX_INSTRUMENTATION
 319   else {
 320     BX_INSTR_CNEAR_BRANCH_NOT_TAKEN(BX_CPU_ID);
 321   }
 322 #endif
 323 }
 324
 325 void BX_CPP_AttrRegparmN(1) BX_CPU_C::JS_Jq(bxInstruction_c *i)
 326 {
 327   if (get_SF()) {
 328     branch_near64(i);
 329     BX_INSTR_CNEAR_BRANCH_TAKEN(BX_CPU_ID, RIP);
 330   }
 331 #if BX_INSTRUMENTATION
 332   else {
 333     BX_INSTR_CNEAR_BRANCH_NOT_TAKEN(BX_CPU_ID);
 334   }
 335 #endif
 336 }
 337
 338 void BX_CPP_AttrRegparmN(1) BX_CPU_C::JNS_Jq(bxInstruction_c *i)
 339 {
 340   if (! get_SF()) {
 341     branch_near64(i);
 342     BX_INSTR_CNEAR_BRANCH_TAKEN(BX_CPU_ID, RIP);
 343   }
 344 #if BX_INSTRUMENTATION
 345   else {
 346     BX_INSTR_CNEAR_BRANCH_NOT_TAKEN(BX_CPU_ID);
 347   }
 348 #endif
 349 }
 350
 351 void BX_CPP_AttrRegparmN(1) BX_CPU_C::JP_Jq(bxInstruction_c *i)
 352 {
 353   if (get_PF()) {
 354     branch_near64(i);
 355     BX_INSTR_CNEAR_BRANCH_TAKEN(BX_CPU_ID, RIP);
 356   }
 357 #if BX_INSTRUMENTATION
 358   else {
 359     BX_INSTR_CNEAR_BRANCH_NOT_TAKEN(BX_CPU_ID);
 360   }
 361 #endif
 362 }
 363
 364 void BX_CPP_AttrRegparmN(1) BX_CPU_C::JNP_Jq(bxInstruction_c *i)
 365 {
 366   if (! get_PF()) {
 367     branch_near64(i);
 368     BX_INSTR_CNEAR_BRANCH_TAKEN(BX_CPU_ID, RIP);
 369   }
 370 #if BX_INSTRUMENTATION
 371   else {
 372     BX_INSTR_CNEAR_BRANCH_NOT_TAKEN(BX_CPU_ID);
 373   }
 374 #endif
 375 }
 376
 377 void BX_CPP_AttrRegparmN(1) BX_CPU_C::JL_Jq(bxInstruction_c *i)
 378 {
 379   if (getB_SF() != getB_OF()) {
 380     branch_near64(i);
 381     BX_INSTR_CNEAR_BRANCH_TAKEN(BX_CPU_ID, RIP);
 382   }
 383 #if BX_INSTRUMENTATION
 384   else {
 385     BX_INSTR_CNEAR_BRANCH_NOT_TAKEN(BX_CPU_ID);
 386   }
 387 #endif
 388 }
 389
 390 void BX_CPP_AttrRegparmN(1) BX_CPU_C::JNL_Jq(bxInstruction_c *i)
 391 {
 392   if (getB_SF() == getB_OF()) {
 393     branch_near64(i);
 394     BX_INSTR_CNEAR_BRANCH_TAKEN(BX_CPU_ID, RIP);
 395   }
 396 #if BX_INSTRUMENTATION
 397   else {
 398     BX_INSTR_CNEAR_BRANCH_NOT_TAKEN(BX_CPU_ID);
 399   }
 400 #endif
 401 }
 402
 403 void BX_CPP_AttrRegparmN(1) BX_CPU_C::JLE_Jq(bxInstruction_c *i)
 404 {
 405   if (get_ZF() || (getB_SF() != getB_OF())) {
 406     branch_near64(i);
 407     BX_INSTR_CNEAR_BRANCH_TAKEN(BX_CPU_ID, RIP);
 408   }
 409 #if BX_INSTRUMENTATION
 410   else {
 411     BX_INSTR_CNEAR_BRANCH_NOT_TAKEN(BX_CPU_ID);
 412   }
 413 #endif
 414 }
 415
 416 void BX_CPP_AttrRegparmN(1) BX_CPU_C::JNLE_Jq(bxInstruction_c *i)
 417 {
 418   if (! get_ZF() && (getB_SF() == getB_OF())) {
 419     branch_near64(i);
 420     BX_INSTR_CNEAR_BRANCH_TAKEN(BX_CPU_ID, RIP);
 421   }
 422 #if BX_INSTRUMENTATION
 423   else {
 424     BX_INSTR_CNEAR_BRANCH_NOT_TAKEN(BX_CPU_ID);
 425   }
 426 #endif
 427 }
 428
 429 void BX_CPP_AttrRegparmN(1) BX_CPU_C::JMP_EqR(bxInstruction_c *i)
 430 {
 431   Bit64u op1_64 = BX_READ_64BIT_REG(i->rm());
 432
 433   if (! IsCanonical(op1_64)) {
 434     BX_ERROR(("JMP_Eq: canonical RIP violation"));
 435     exception(BX_GP_EXCEPTION, 0, 0);
 436   }
 437
 438   RIP = op1_64;
 439
 440   BX_INSTR_UCNEAR_BRANCH(BX_CPU_ID, BX_INSTR_IS_JMP, RIP);
 441 }
 442
 443 /* Far indirect jump */
 444 void BX_CPP_AttrRegparmN(1) BX_CPU_C::JMP64_Ep(bxInstruction_c *i)
 445 {
 446   invalidate_prefetch_q();
 447
 448   bx_address eaddr = BX_CPU_CALL_METHODR(i->ResolveModrm, (i));
 449
 450   Bit64u op1_64 = read_virtual_qword_64(i->seg(), eaddr);
 451   Bit16u cs_raw = read_virtual_word_64(i->seg(), eaddr+8);
 452
 453   BX_ASSERT(protected_mode());
 454
 455   jump_protected(i, cs_raw, op1_64);
 456
 457   BX_INSTR_FAR_BRANCH(BX_CPU_ID, BX_INSTR_IS_JMP,
 458                       BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.value, RIP);
 459 }
 460
 461 void BX_CPP_AttrRegparmN(1) BX_CPU_C::IRET64(bxInstruction_c *i)
 462 {
 463   invalidate_prefetch_q();
 464
 465 #if BX_DEBUGGER
 466   BX_CPU_THIS_PTR show_flag |= Flag_iret;
 467 #endif
 468
 469   BX_CPU_THIS_PTR disable_NMI = 0;
 470
 471   BX_ASSERT(protected_mode());
 472
 473   BX_CPU_THIS_PTR speculative_rsp = 1;
 474   BX_CPU_THIS_PTR prev_rsp = RSP;
 475
 476   // long_iret is not RSP safe
 477   long_iret(i);
 478
 479   BX_CPU_THIS_PTR speculative_rsp = 0;
 480
 481   BX_INSTR_FAR_BRANCH(BX_CPU_ID, BX_INSTR_IS_IRET,
 482                       BX_CPU_THIS_PTR sregs[BX_SEG_REG_CS].selector.value, RIP);
 483 }
 484
 485 void BX_CPP_AttrRegparmN(1) BX_CPU_C::JRCXZ_Jb(bxInstruction_c *i)
 486 {
 487   Bit64u temp_RCX;
 488
 489   if (i->as64L())
 490     temp_RCX = RCX;
 491   else
 492     temp_RCX = ECX;
 493
 494   if (temp_RCX == 0) {
 495     branch_near64(i);
 496     BX_INSTR_CNEAR_BRANCH_TAKEN(BX_CPU_ID, RIP);
 497   }
 498 #if BX_INSTRUMENTATION
 499   else {
 500     BX_INSTR_CNEAR_BRANCH_NOT_TAKEN(BX_CPU_ID);
 501   }
 502 #endif
 503 }
 504
 505 //
 506 // There is some weirdness in LOOP instructions definition. If an exception
 507 // was generated during the instruction execution (for example #GP fault
 508 // because EIP was beyond CS segment limits) CPU state should restore the
 509 // state prior to instruction execution.
 510 //
 511 // The final point that we are not allowed to decrement RCX register before
 512 // it is known that no exceptions can happen.
 513 //
 514
 515 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LOOPNE64_Jb(bxInstruction_c *i)
 516 {
 517   if (i->as64L()) {
 518     Bit64u count = RCX;
 519
 520     if (((--count) != 0) && (get_ZF()==0)) {
 521       branch_near64(i);
 522       BX_INSTR_CNEAR_BRANCH_TAKEN(BX_CPU_ID, RIP);
 523     }
 524 #if BX_INSTRUMENTATION
 525     else {
 526       BX_INSTR_CNEAR_BRANCH_NOT_TAKEN(BX_CPU_ID);
 527     }
 528 #endif
 529
 530     RCX = count;
 531   }
 532   else {
 533     Bit32u count = ECX;
 534
 535     if (((--count) != 0) && (get_ZF()==0)) {
 536       branch_near64(i);
 537       BX_INSTR_CNEAR_BRANCH_TAKEN(BX_CPU_ID, RIP);
 538     }
 539 #if BX_INSTRUMENTATION
 540     else {
 541       BX_INSTR_CNEAR_BRANCH_NOT_TAKEN(BX_CPU_ID);
 542     }
 543 #endif
 544
 545     RCX = count;
 546   }
 547 }
 548
 549 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LOOPE64_Jb(bxInstruction_c *i)
 550 {
 551   if (i->as64L()) {
 552     Bit64u count = RCX;
 553
 554     if (((--count) != 0) && get_ZF()) {
 555       branch_near64(i);
 556       BX_INSTR_CNEAR_BRANCH_TAKEN(BX_CPU_ID, RIP);
 557     }
 558 #if BX_INSTRUMENTATION
 559     else {
 560       BX_INSTR_CNEAR_BRANCH_NOT_TAKEN(BX_CPU_ID);
 561     }
 562 #endif
 563
 564     RCX = count;
 565   }
 566   else {
 567     Bit32u count = ECX;
 568
 569     if (((--count) != 0) && get_ZF()) {
 570       branch_near64(i);
 571       BX_INSTR_CNEAR_BRANCH_TAKEN(BX_CPU_ID, RIP);
 572     }
 573 #if BX_INSTRUMENTATION
 574     else {
 575       BX_INSTR_CNEAR_BRANCH_NOT_TAKEN(BX_CPU_ID);
 576     }
 577 #endif
 578
 579     RCX = count;
 580   }
 581 }
 582
 583 void BX_CPP_AttrRegparmN(1) BX_CPU_C::LOOP64_Jb(bxInstruction_c *i)
 584 {
 585   if (i->as64L()) {
 586     Bit64u count = RCX;
 587
 588     if ((--count) != 0) {
 589       branch_near64(i);
 590       BX_INSTR_CNEAR_BRANCH_TAKEN(BX_CPU_ID, RIP);
 591     }
 592 #if BX_INSTRUMENTATION
 593     else {
 594       BX_INSTR_CNEAR_BRANCH_NOT_TAKEN(BX_CPU_ID);
 595     }
 596 #endif
 597
 598     RCX = count;
 599   }
 600   else {
 601     Bit32u count = ECX;
 602
 603     if ((--count) != 0) {
 604       branch_near64(i);
 605       BX_INSTR_CNEAR_BRANCH_TAKEN(BX_CPU_ID, RIP);
 606     }
 607 #if BX_INSTRUMENTATION
 608     else {
 609       BX_INSTR_CNEAR_BRANCH_NOT_TAKEN(BX_CPU_ID);
 610     }
 611 #endif
 612
 613     RCX = count;
 614   }
 615 }
 616
 617 #endif /* if BX_SUPPORT_X86_64 */