assembler/MacroAssemblerX86_64.h

   1 /*
   2  * Copyright (C) 2008, 2012 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef MacroAssemblerX86_64_h
  27 #define MacroAssemblerX86_64_h
  28
  29 #if ENABLE(ASSEMBLER) && CPU(X86_64)
  30
  31 #include "MacroAssemblerX86Common.h"
  32
  33 #define REPTACH_OFFSET_CALL_R11 3
  34
  35 namespace JSC {
  36
  37 class MacroAssemblerX86_64 : public MacroAssemblerX86Common {
  38 public:
  39     static const Scale ScalePtr = TimesEight;
  40
  41     using MacroAssemblerX86Common::add32;
  42     using MacroAssemblerX86Common::and32;
  43     using MacroAssemblerX86Common::branchAdd32;
  44     using MacroAssemblerX86Common::or32;
  45     using MacroAssemblerX86Common::sub32;
  46     using MacroAssemblerX86Common::load32;
  47     using MacroAssemblerX86Common::store32;
  48     using MacroAssemblerX86Common::store8;
  49     using MacroAssemblerX86Common::call;
  50     using MacroAssemblerX86Common::jump;
  51     using MacroAssemblerX86Common::addDouble;
  52     using MacroAssemblerX86Common::loadDouble;
  53     using MacroAssemblerX86Common::convertInt32ToDouble;
  54
  55     void add32(TrustedImm32 imm, AbsoluteAddress address)
  56     {
  57         move(TrustedImmPtr(address.m_ptr), scratchRegister);
  58         add32(imm, Address(scratchRegister));
  59     }
  60
  61     void and32(TrustedImm32 imm, AbsoluteAddress address)
  62     {
  63         move(TrustedImmPtr(address.m_ptr), scratchRegister);
  64         and32(imm, Address(scratchRegister));
  65     }
  66
  67     void add32(AbsoluteAddress address, RegisterID dest)
  68     {
  69         move(TrustedImmPtr(address.m_ptr), scratchRegister);
  70         add32(Address(scratchRegister), dest);
  71     }
  72
  73     void or32(TrustedImm32 imm, AbsoluteAddress address)
  74     {
  75         move(TrustedImmPtr(address.m_ptr), scratchRegister);
  76         or32(imm, Address(scratchRegister));
  77     }
  78
  79     void or32(RegisterID reg, AbsoluteAddress address)
  80     {
  81         move(TrustedImmPtr(address.m_ptr), scratchRegister);
  82         or32(reg, Address(scratchRegister));
  83     }
  84
  85     void sub32(TrustedImm32 imm, AbsoluteAddress address)
  86     {
  87         move(TrustedImmPtr(address.m_ptr), scratchRegister);
  88         sub32(imm, Address(scratchRegister));
  89     }
  90
  91     void load32(const void* address, RegisterID dest)
  92     {
  93         if (dest == X86Registers::eax)
  94             m_assembler.movl_mEAX(address);
  95         else {
  96             move(TrustedImmPtr(address), dest);
  97             load32(dest, dest);
  98         }
  99     }
 100
 101     void addDouble(AbsoluteAddress address, FPRegisterID dest)
 102     {
 103         move(TrustedImmPtr(address.m_ptr), scratchRegister);
 104         m_assembler.addsd_mr(0, scratchRegister, dest);
 105     }
 106
 107     void convertInt32ToDouble(TrustedImm32 imm, FPRegisterID dest)
 108     {
 109         move(imm, scratchRegister);
 110         m_assembler.cvtsi2sd_rr(scratchRegister, dest);
 111     }
 112
 113     void store32(TrustedImm32 imm, void* address)
 114     {
 115         move(TrustedImmPtr(address), scratchRegister);
 116         store32(imm, scratchRegister);
 117     }
 118
 119     void store8(TrustedImm32 imm, void* address)
 120     {
 121         move(TrustedImmPtr(address), scratchRegister);
 122         store8(imm, Address(scratchRegister));
 123     }
 124
 125     Call call()
 126     {
 127         DataLabelPtr label = moveWithPatch(TrustedImmPtr(0), scratchRegister);
 128         Call result = Call(m_assembler.call(scratchRegister), Call::Linkable);
 129         ASSERT_UNUSED(label, differenceBetween(label, result) == REPTACH_OFFSET_CALL_R11);
 130         return result;
 131     }
 132
 133     // Address is a memory location containing the address to jump to
 134     void jump(AbsoluteAddress address)
 135     {
 136         move(TrustedImmPtr(address.m_ptr), scratchRegister);
 137         jump(Address(scratchRegister));
 138     }
 139
 140     Call tailRecursiveCall()
 141     {
 142         DataLabelPtr label = moveWithPatch(TrustedImmPtr(0), scratchRegister);
 143         Jump newJump = Jump(m_assembler.jmp_r(scratchRegister));
 144         ASSERT_UNUSED(label, differenceBetween(label, newJump) == REPTACH_OFFSET_CALL_R11);
 145         return Call::fromTailJump(newJump);
 146     }
 147
 148     Call makeTailRecursiveCall(Jump oldJump)
 149     {
 150         oldJump.link(this);
 151         DataLabelPtr label = moveWithPatch(TrustedImmPtr(0), scratchRegister);
 152         Jump newJump = Jump(m_assembler.jmp_r(scratchRegister));
 153         ASSERT_UNUSED(label, differenceBetween(label, newJump) == REPTACH_OFFSET_CALL_R11);
 154         return Call::fromTailJump(newJump);
 155     }
 156
 157     Jump branchAdd32(ResultCondition cond, TrustedImm32 src, AbsoluteAddress dest)
 158     {
 159         move(TrustedImmPtr(dest.m_ptr), scratchRegister);
 160         add32(src, Address(scratchRegister));
 161         return Jump(m_assembler.jCC(x86Condition(cond)));
 162     }
 163
 164     void add64(RegisterID src, RegisterID dest)
 165     {
 166         m_assembler.addq_rr(src, dest);
 167     }
 168
 169     void add64(Address src, RegisterID dest)
 170     {
 171         m_assembler.addq_mr(src.offset, src.base, dest);
 172     }
 173
 174     void add64(AbsoluteAddress src, RegisterID dest)
 175     {
 176         move(TrustedImmPtr(src.m_ptr), scratchRegister);
 177         add64(Address(scratchRegister), dest);
 178     }
 179
 180     void add64(TrustedImm32 imm, RegisterID srcDest)
 181     {
 182         m_assembler.addq_ir(imm.m_value, srcDest);
 183     }
 184
 185     void add64(TrustedImm64 imm, RegisterID dest)
 186     {
 187         move(imm, scratchRegister);
 188         add64(scratchRegister, dest);
 189     }
 190
 191     void add64(TrustedImm32 imm, RegisterID src, RegisterID dest)
 192     {
 193         m_assembler.leaq_mr(imm.m_value, src, dest);
 194     }
 195
 196     void add64(TrustedImm32 imm, Address address)
 197     {
 198         m_assembler.addq_im(imm.m_value, address.offset, address.base);
 199     }
 200
 201     void add64(TrustedImm32 imm, AbsoluteAddress address)
 202     {
 203         move(TrustedImmPtr(address.m_ptr), scratchRegister);
 204         add64(imm, Address(scratchRegister));
 205     }
 206
 207     void and64(RegisterID src, RegisterID dest)
 208     {
 209         m_assembler.andq_rr(src, dest);
 210     }
 211
 212     void and64(TrustedImm32 imm, RegisterID srcDest)
 213     {
 214         m_assembler.andq_ir(imm.m_value, srcDest);
 215     }
 216
 217     void neg64(RegisterID dest)
 218     {
 219         m_assembler.negq_r(dest);
 220     }
 221
 222     void or64(RegisterID src, RegisterID dest)
 223     {
 224         m_assembler.orq_rr(src, dest);
 225     }
 226
 227     void or64(TrustedImm64 imm, RegisterID dest)
 228     {
 229         move(imm, scratchRegister);
 230         or64(scratchRegister, dest);
 231     }
 232
 233     void or64(TrustedImm32 imm, RegisterID dest)
 234     {
 235         m_assembler.orq_ir(imm.m_value, dest);
 236     }
 237
 238     void or64(RegisterID op1, RegisterID op2, RegisterID dest)
 239     {
 240         if (op1 == op2)
 241             move(op1, dest);
 242         else if (op1 == dest)
 243             or64(op2, dest);
 244         else {
 245             move(op2, dest);
 246             or64(op1, dest);
 247         }
 248     }
 249
 250     void or64(TrustedImm32 imm, RegisterID src, RegisterID dest)
 251     {
 252         move(src, dest);
 253         or64(imm, dest);
 254     }
 255
 256     void rotateRight64(TrustedImm32 imm, RegisterID srcDst)
 257     {
 258         m_assembler.rorq_i8r(imm.m_value, srcDst);
 259     }
 260
 261     void sub64(RegisterID src, RegisterID dest)
 262     {
 263         m_assembler.subq_rr(src, dest);
 264     }
 265
 266     void sub64(TrustedImm32 imm, RegisterID dest)
 267     {
 268         m_assembler.subq_ir(imm.m_value, dest);
 269     }
 270
 271     void sub64(TrustedImm64 imm, RegisterID dest)
 272     {
 273         move(imm, scratchRegister);
 274         sub64(scratchRegister, dest);
 275     }
 276
 277     void xor64(RegisterID src, RegisterID dest)
 278     {
 279         m_assembler.xorq_rr(src, dest);
 280     }
 281
 282     void xor64(RegisterID src, Address dest)
 283     {
 284         m_assembler.xorq_rm(src, dest.offset, dest.base);
 285     }
 286
 287     void xor64(TrustedImm32 imm, RegisterID srcDest)
 288     {
 289         m_assembler.xorq_ir(imm.m_value, srcDest);
 290     }
 291
 292     void load64(ImplicitAddress address, RegisterID dest)
 293     {
 294         m_assembler.movq_mr(address.offset, address.base, dest);
 295     }
 296
 297     void load64(BaseIndex address, RegisterID dest)
 298     {
 299         m_assembler.movq_mr(address.offset, address.base, address.index, address.scale, dest);
 300     }
 301
 302     void load64(const void* address, RegisterID dest)
 303     {
 304         if (dest == X86Registers::eax)
 305             m_assembler.movq_mEAX(address);
 306         else {
 307             move(TrustedImmPtr(address), dest);
 308             load64(dest, dest);
 309         }
 310     }
 311
 312     DataLabel32 load64WithAddressOffsetPatch(Address address, RegisterID dest)
 313     {
 314         padBeforePatch();
 315         m_assembler.movq_mr_disp32(address.offset, address.base, dest);
 316         return DataLabel32(this);
 317     }
 318
 319     DataLabelCompact load64WithCompactAddressOffsetPatch(Address address, RegisterID dest)
 320     {
 321         padBeforePatch();
 322         m_assembler.movq_mr_disp8(address.offset, address.base, dest);
 323         return DataLabelCompact(this);
 324     }
 325
 326     void store64(RegisterID src, ImplicitAddress address)
 327     {
 328         m_assembler.movq_rm(src, address.offset, address.base);
 329     }
 330
 331     void store64(RegisterID src, BaseIndex address)
 332     {
 333         m_assembler.movq_rm(src, address.offset, address.base, address.index, address.scale);
 334     }
 335
 336     void store64(RegisterID src, void* address)
 337     {
 338         if (src == X86Registers::eax)
 339             m_assembler.movq_EAXm(address);
 340         else {
 341             move(TrustedImmPtr(address), scratchRegister);
 342             store64(src, scratchRegister);
 343         }
 344     }
 345
 346     void store64(TrustedImm64 imm, ImplicitAddress address)
 347     {
 348         move(imm, scratchRegister);
 349         store64(scratchRegister, address);
 350     }
 351
 352     void store64(TrustedImm64 imm, BaseIndex address)
 353     {
 354         move(imm, scratchRegister);
 355         m_assembler.movq_rm(scratchRegister, address.offset, address.base, address.index, address.scale);
 356     }
 357
 358     DataLabel32 store64WithAddressOffsetPatch(RegisterID src, Address address)
 359     {
 360         padBeforePatch();
 361         m_assembler.movq_rm_disp32(src, address.offset, address.base);
 362         return DataLabel32(this);
 363     }
 364
 365     void move64ToDouble(RegisterID src, FPRegisterID dest)
 366     {
 367         m_assembler.movq_rr(src, dest);
 368     }
 369
 370     void moveDoubleTo64(FPRegisterID src, RegisterID dest)
 371     {
 372         m_assembler.movq_rr(src, dest);
 373     }
 374
 375     void compare64(RelationalCondition cond, RegisterID left, TrustedImm32 right, RegisterID dest)
 376     {
 377         if (((cond == Equal) || (cond == NotEqual)) && !right.m_value)
 378             m_assembler.testq_rr(left, left);
 379         else
 380             m_assembler.cmpq_ir(right.m_value, left);
 381         m_assembler.setCC_r(x86Condition(cond), dest);
 382         m_assembler.movzbl_rr(dest, dest);
 383     }
 384
 385     void compare64(RelationalCondition cond, RegisterID left, RegisterID right, RegisterID dest)
 386     {
 387         m_assembler.cmpq_rr(right, left);
 388         m_assembler.setCC_r(x86Condition(cond), dest);
 389         m_assembler.movzbl_rr(dest, dest);
 390     }
 391
 392     Jump branch64(RelationalCondition cond, RegisterID left, RegisterID right)
 393     {
 394         m_assembler.cmpq_rr(right, left);
 395         return Jump(m_assembler.jCC(x86Condition(cond)));
 396     }
 397
 398     Jump branch64(RelationalCondition cond, RegisterID left, TrustedImm64 right)
 399     {
 400         if (((cond == Equal) || (cond == NotEqual)) && !right.m_value) {
 401             m_assembler.testq_rr(left, left);
 402             return Jump(m_assembler.jCC(x86Condition(cond)));
 403         }
 404         move(right, scratchRegister);
 405         return branch64(cond, left, scratchRegister);
 406     }
 407
 408     Jump branch64(RelationalCondition cond, RegisterID left, Address right)
 409     {
 410         m_assembler.cmpq_mr(right.offset, right.base, left);
 411         return Jump(m_assembler.jCC(x86Condition(cond)));
 412     }
 413
 414     Jump branch64(RelationalCondition cond, AbsoluteAddress left, RegisterID right)
 415     {
 416         move(TrustedImmPtr(left.m_ptr), scratchRegister);
 417         return branch64(cond, Address(scratchRegister), right);
 418     }
 419
 420     Jump branch64(RelationalCondition cond, Address left, RegisterID right)
 421     {
 422         m_assembler.cmpq_rm(right, left.offset, left.base);
 423         return Jump(m_assembler.jCC(x86Condition(cond)));
 424     }
 425
 426     Jump branch64(RelationalCondition cond, Address left, TrustedImm64 right)
 427     {
 428         move(right, scratchRegister);
 429         return branch64(cond, left, scratchRegister);
 430     }
 431
 432     Jump branchTest64(ResultCondition cond, RegisterID reg, RegisterID mask)
 433     {
 434         m_assembler.testq_rr(reg, mask);
 435         return Jump(m_assembler.jCC(x86Condition(cond)));
 436     }
 437
 438     Jump branchTest64(ResultCondition cond, RegisterID reg, TrustedImm32 mask = TrustedImm32(-1))
 439     {
 440         // if we are only interested in the low seven bits, this can be tested with a testb
 441         if (mask.m_value == -1)
 442             m_assembler.testq_rr(reg, reg);
 443         else if ((mask.m_value & ~0x7f) == 0)
 444             m_assembler.testb_i8r(mask.m_value, reg);
 445         else
 446             m_assembler.testq_i32r(mask.m_value, reg);
 447         return Jump(m_assembler.jCC(x86Condition(cond)));
 448     }
 449
 450     void test64(ResultCondition cond, RegisterID reg, TrustedImm32 mask, RegisterID dest)
 451     {
 452         if (mask.m_value == -1)
 453             m_assembler.testq_rr(reg, reg);
 454         else if ((mask.m_value & ~0x7f) == 0)
 455             m_assembler.testb_i8r(mask.m_value, reg);
 456         else
 457             m_assembler.testq_i32r(mask.m_value, reg);
 458         set32(x86Condition(cond), dest);
 459     }
 460
 461     void test64(ResultCondition cond, RegisterID reg, RegisterID mask, RegisterID dest)
 462     {
 463         m_assembler.testq_rr(reg, mask);
 464         set32(x86Condition(cond), dest);
 465     }
 466
 467     Jump branchTest64(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
 468     {
 469         load64(address.m_ptr, scratchRegister);
 470         return branchTest64(cond, scratchRegister, mask);
 471     }
 472
 473     Jump branchTest64(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
 474     {
 475         if (mask.m_value == -1)
 476             m_assembler.cmpq_im(0, address.offset, address.base);
 477         else
 478             m_assembler.testq_i32m(mask.m_value, address.offset, address.base);
 479         return Jump(m_assembler.jCC(x86Condition(cond)));
 480     }
 481
 482     Jump branchTest64(ResultCondition cond, Address address, RegisterID reg)
 483     {
 484         m_assembler.testq_rm(reg, address.offset, address.base);
 485         return Jump(m_assembler.jCC(x86Condition(cond)));
 486     }
 487
 488     Jump branchTest64(ResultCondition cond, BaseIndex address, TrustedImm32 mask = TrustedImm32(-1))
 489     {
 490         if (mask.m_value == -1)
 491             m_assembler.cmpq_im(0, address.offset, address.base, address.index, address.scale);
 492         else
 493             m_assembler.testq_i32m(mask.m_value, address.offset, address.base, address.index, address.scale);
 494         return Jump(m_assembler.jCC(x86Condition(cond)));
 495     }
 496
 497
 498     Jump branchAdd64(ResultCondition cond, TrustedImm32 imm, RegisterID dest)
 499     {
 500         add64(imm, dest);
 501         return Jump(m_assembler.jCC(x86Condition(cond)));
 502     }
 503
 504     Jump branchAdd64(ResultCondition cond, RegisterID src, RegisterID dest)
 505     {
 506         add64(src, dest);
 507         return Jump(m_assembler.jCC(x86Condition(cond)));
 508     }
 509
 510     Jump branchSub64(ResultCondition cond, TrustedImm32 imm, RegisterID dest)
 511     {
 512         sub64(imm, dest);
 513         return Jump(m_assembler.jCC(x86Condition(cond)));
 514     }
 515
 516     Jump branchSub64(ResultCondition cond, RegisterID src, RegisterID dest)
 517     {
 518         sub64(src, dest);
 519         return Jump(m_assembler.jCC(x86Condition(cond)));
 520     }
 521
 522     Jump branchSub64(ResultCondition cond, RegisterID src1, TrustedImm32 src2, RegisterID dest)
 523     {
 524         move(src1, dest);
 525         return branchSub64(cond, src2, dest);
 526     }
 527
 528     ConvertibleLoadLabel convertibleLoadPtr(Address address, RegisterID dest)
 529     {
 530         ConvertibleLoadLabel result = ConvertibleLoadLabel(this);
 531         m_assembler.movq_mr(address.offset, address.base, dest);
 532         return result;
 533     }
 534
 535     DataLabelPtr moveWithPatch(TrustedImmPtr initialValue, RegisterID dest)
 536     {
 537         padBeforePatch();
 538         m_assembler.movq_i64r(initialValue.asIntptr(), dest);
 539         return DataLabelPtr(this);
 540     }
 541
 542     Jump branchPtrWithPatch(RelationalCondition cond, RegisterID left, DataLabelPtr& dataLabel, TrustedImmPtr initialRightValue = TrustedImmPtr(0))
 543     {
 544         dataLabel = moveWithPatch(initialRightValue, scratchRegister);
 545         return branch64(cond, left, scratchRegister);
 546     }
 547
 548     Jump branchPtrWithPatch(RelationalCondition cond, Address left, DataLabelPtr& dataLabel, TrustedImmPtr initialRightValue = TrustedImmPtr(0))
 549     {
 550         dataLabel = moveWithPatch(initialRightValue, scratchRegister);
 551         return branch64(cond, left, scratchRegister);
 552     }
 553
 554     DataLabelPtr storePtrWithPatch(TrustedImmPtr initialValue, ImplicitAddress address)
 555     {
 556         DataLabelPtr label = moveWithPatch(initialValue, scratchRegister);
 557         store64(scratchRegister, address);
 558         return label;
 559     }
 560
 561     using MacroAssemblerX86Common::branchTest8;
 562     Jump branchTest8(ResultCondition cond, ExtendedAddress address, TrustedImm32 mask = TrustedImm32(-1))
 563     {
 564         TrustedImmPtr addr(reinterpret_cast<void*>(address.offset));
 565         MacroAssemblerX86Common::move(addr, scratchRegister);
 566         return MacroAssemblerX86Common::branchTest8(cond, BaseIndex(scratchRegister, address.base, TimesOne), mask);
 567     }
 568
 569     Jump branchTest8(ResultCondition cond, AbsoluteAddress address, TrustedImm32 mask = TrustedImm32(-1))
 570     {
 571         MacroAssemblerX86Common::move(TrustedImmPtr(address.m_ptr), scratchRegister);
 572         return MacroAssemblerX86Common::branchTest8(cond, Address(scratchRegister), mask);
 573     }
 574
 575     static bool supportsFloatingPoint() { return true; }
 576     // See comment on MacroAssemblerARMv7::supportsFloatingPointTruncate()
 577     static bool supportsFloatingPointTruncate() { return true; }
 578     static bool supportsFloatingPointSqrt() { return true; }
 579     static bool supportsFloatingPointAbs() { return true; }
 580
 581     static FunctionPtr readCallTarget(CodeLocationCall call)
 582     {
 583         return FunctionPtr(X86Assembler::readPointer(call.dataLabelPtrAtOffset(-REPTACH_OFFSET_CALL_R11).dataLocation()));
 584     }
 585
 586     static RegisterID scratchRegisterForBlinding() { return scratchRegister; }
 587
 588     static bool canJumpReplacePatchableBranchPtrWithPatch() { return true; }
 589
 590     static CodeLocationLabel startOfBranchPtrWithPatchOnRegister(CodeLocationDataLabelPtr label)
 591     {
 592         const int rexBytes = 1;
 593         const int opcodeBytes = 1;
 594         const int immediateBytes = 8;
 595         const int totalBytes = rexBytes + opcodeBytes + immediateBytes;
 596         ASSERT(totalBytes >= maxJumpReplacementSize());
 597         return label.labelAtOffset(-totalBytes);
 598     }
 599
 600     static CodeLocationLabel startOfPatchableBranchPtrWithPatchOnAddress(CodeLocationDataLabelPtr label)
 601     {
 602         return startOfBranchPtrWithPatchOnRegister(label);
 603     }
 604
 605     static void revertJumpReplacementToPatchableBranchPtrWithPatch(CodeLocationLabel instructionStart, Address, void* initialValue)
 606     {
 607         X86Assembler::revertJumpTo_movq_i64r(instructionStart.executableAddress(), reinterpret_cast<intptr_t>(initialValue), scratchRegister);
 608     }
 609
 610     static void revertJumpReplacementToBranchPtrWithPatch(CodeLocationLabel instructionStart, RegisterID, void* initialValue)
 611     {
 612         X86Assembler::revertJumpTo_movq_i64r(instructionStart.executableAddress(), reinterpret_cast<intptr_t>(initialValue), scratchRegister);
 613     }
 614
 615 private:
 616     friend class LinkBuffer;
 617     friend class RepatchBuffer;
 618
 619     static void linkCall(void* code, Call call, FunctionPtr function)
 620     {
 621         if (!call.isFlagSet(Call::Near))
 622             X86Assembler::linkPointer(code, call.m_label.labelAtOffset(-REPTACH_OFFSET_CALL_R11), function.value());
 623         else
 624             X86Assembler::linkCall(code, call.m_label, function.value());
 625     }
 626
 627     static void repatchCall(CodeLocationCall call, CodeLocationLabel destination)
 628     {
 629         X86Assembler::repatchPointer(call.dataLabelPtrAtOffset(-REPTACH_OFFSET_CALL_R11).dataLocation(), destination.executableAddress());
 630     }
 631
 632     static void repatchCall(CodeLocationCall call, FunctionPtr destination)
 633     {
 634         X86Assembler::repatchPointer(call.dataLabelPtrAtOffset(-REPTACH_OFFSET_CALL_R11).dataLocation(), destination.executableAddress());
 635     }
 636
 637 };
 638
 639 } // namespace JSC
 640
 641 #endif // ENABLE(ASSEMBLER)
 642
 643 #endif // MacroAssemblerX86_64_h