src/compiler/x64/code-generator-x64.cc

   1 // Copyright 2013 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "src/compiler/code-generator.h"
   6
   7 #include "src/compiler/code-generator-impl.h"
   8 #include "src/compiler/gap-resolver.h"
   9 #include "src/compiler/node-matchers.h"
  10 #include "src/compiler/node-properties-inl.h"
  11 #include "src/scopes.h"
  12 #include "src/x64/assembler-x64.h"
  13 #include "src/x64/macro-assembler-x64.h"
  14
  15 namespace v8 {
  16 namespace internal {
  17 namespace compiler {
  18
  19 #define __ masm()->
  20
  21
  22 // Adds X64 specific methods for decoding operands.
  23 class X64OperandConverter : public InstructionOperandConverter {
  24  public:
  25   X64OperandConverter(CodeGenerator* gen, Instruction* instr)
  26       : InstructionOperandConverter(gen, instr) {}
  27
  28   Immediate InputImmediate(int index) {
  29     return ToImmediate(instr_->InputAt(index));
  30   }
  31
  32   Operand InputOperand(int index) { return ToOperand(instr_->InputAt(index)); }
  33
  34   Operand OutputOperand() { return ToOperand(instr_->Output()); }
  35
  36   Immediate ToImmediate(InstructionOperand* operand) {
  37     return Immediate(ToConstant(operand).ToInt32());
  38   }
  39
  40   Operand ToOperand(InstructionOperand* op, int extra = 0) {
  41     DCHECK(op->IsStackSlot() || op->IsDoubleStackSlot());
  42     // The linkage computes where all spill slots are located.
  43     FrameOffset offset = linkage()->GetFrameOffset(op->index(), frame(), extra);
  44     return Operand(offset.from_stack_pointer() ? rsp : rbp, offset.offset());
  45   }
  46
  47   static int NextOffset(int* offset) {
  48     int i = *offset;
  49     (*offset)++;
  50     return i;
  51   }
  52
  53   static ScaleFactor ScaleFor(AddressingMode one, AddressingMode mode) {
  54     STATIC_ASSERT(0 == static_cast<int>(times_1));
  55     STATIC_ASSERT(1 == static_cast<int>(times_2));
  56     STATIC_ASSERT(2 == static_cast<int>(times_4));
  57     STATIC_ASSERT(3 == static_cast<int>(times_8));
  58     int scale = static_cast<int>(mode - one);
  59     DCHECK(scale >= 0 && scale < 4);
  60     return static_cast<ScaleFactor>(scale);
  61   }
  62
  63   Operand MemoryOperand(int* offset) {
  64     AddressingMode mode = AddressingModeField::decode(instr_->opcode());
  65     switch (mode) {
  66       case kMode_MR: {
  67         Register base = InputRegister(NextOffset(offset));
  68         int32_t disp = 0;
  69         return Operand(base, disp);
  70       }
  71       case kMode_MRI: {
  72         Register base = InputRegister(NextOffset(offset));
  73         int32_t disp = InputInt32(NextOffset(offset));
  74         return Operand(base, disp);
  75       }
  76       case kMode_MR1:
  77       case kMode_MR2:
  78       case kMode_MR4:
  79       case kMode_MR8: {
  80         Register base = InputRegister(NextOffset(offset));
  81         Register index = InputRegister(NextOffset(offset));
  82         ScaleFactor scale = ScaleFor(kMode_MR1, mode);
  83         int32_t disp = 0;
  84         return Operand(base, index, scale, disp);
  85       }
  86       case kMode_MR1I:
  87       case kMode_MR2I:
  88       case kMode_MR4I:
  89       case kMode_MR8I: {
  90         Register base = InputRegister(NextOffset(offset));
  91         Register index = InputRegister(NextOffset(offset));
  92         ScaleFactor scale = ScaleFor(kMode_MR1I, mode);
  93         int32_t disp = InputInt32(NextOffset(offset));
  94         return Operand(base, index, scale, disp);
  95       }
  96       case kMode_M1: {
  97         Register base = InputRegister(NextOffset(offset));
  98         int32_t disp = 0;
  99         return Operand(base, disp);
 100       }
 101       case kMode_M2:
 102         UNREACHABLE();  // Should use kModeMR with more compact encoding instead
 103         return Operand(no_reg, 0);
 104       case kMode_M4:
 105       case kMode_M8: {
 106         Register index = InputRegister(NextOffset(offset));
 107         ScaleFactor scale = ScaleFor(kMode_M1, mode);
 108         int32_t disp = 0;
 109         return Operand(index, scale, disp);
 110       }
 111       case kMode_M1I:
 112       case kMode_M2I:
 113       case kMode_M4I:
 114       case kMode_M8I: {
 115         Register index = InputRegister(NextOffset(offset));
 116         ScaleFactor scale = ScaleFor(kMode_M1I, mode);
 117         int32_t disp = InputInt32(NextOffset(offset));
 118         return Operand(index, scale, disp);
 119       }
 120       case kMode_None:
 121         UNREACHABLE();
 122         return Operand(no_reg, 0);
 123     }
 124     UNREACHABLE();
 125     return Operand(no_reg, 0);
 126   }
 127
 128   Operand MemoryOperand(int first_input = 0) {
 129     return MemoryOperand(&first_input);
 130   }
 131 };
 132
 133
 134 namespace {
 135
 136 bool HasImmediateInput(Instruction* instr, int index) {
 137   return instr->InputAt(index)->IsImmediate();
 138 }
 139
 140
 141 class OutOfLineLoadInteger FINAL : public OutOfLineCode {
 142  public:
 143   OutOfLineLoadInteger(CodeGenerator* gen, Register result)
 144       : OutOfLineCode(gen), result_(result) {}
 145
 146   void Generate() FINAL { __ xorl(result_, result_); }
 147
 148  private:
 149   Register const result_;
 150 };
 151
 152
 153 class OutOfLineLoadFloat FINAL : public OutOfLineCode {
 154  public:
 155   OutOfLineLoadFloat(CodeGenerator* gen, XMMRegister result)
 156       : OutOfLineCode(gen), result_(result) {}
 157
 158   void Generate() FINAL { __ pcmpeqd(result_, result_); }
 159
 160  private:
 161   XMMRegister const result_;
 162 };
 163
 164
 165 class OutOfLineTruncateDoubleToI FINAL : public OutOfLineCode {
 166  public:
 167   OutOfLineTruncateDoubleToI(CodeGenerator* gen, Register result,
 168                              XMMRegister input)
 169       : OutOfLineCode(gen), result_(result), input_(input) {}
 170
 171   void Generate() FINAL {
 172     __ subp(rsp, Immediate(kDoubleSize));
 173     __ movsd(MemOperand(rsp, 0), input_);
 174     __ SlowTruncateToI(result_, rsp, 0);
 175     __ addp(rsp, Immediate(kDoubleSize));
 176   }
 177
 178  private:
 179   Register const result_;
 180   XMMRegister const input_;
 181 };
 182
 183 }  // namespace
 184
 185
 186 #define ASSEMBLE_UNOP(asm_instr)         \
 187   do {                                   \
 188     if (instr->Output()->IsRegister()) { \
 189       __ asm_instr(i.OutputRegister());  \
 190     } else {                             \
 191       __ asm_instr(i.OutputOperand());   \
 192     }                                    \
 193   } while (0)
 194
 195
 196 #define ASSEMBLE_BINOP(asm_instr)                              \
 197   do {                                                         \
 198     if (HasImmediateInput(instr, 1)) {                         \
 199       if (instr->InputAt(0)->IsRegister()) {                   \
 200         __ asm_instr(i.InputRegister(0), i.InputImmediate(1)); \
 201       } else {                                                 \
 202         __ asm_instr(i.InputOperand(0), i.InputImmediate(1));  \
 203       }                                                        \
 204     } else {                                                   \
 205       if (instr->InputAt(1)->IsRegister()) {                   \
 206         __ asm_instr(i.InputRegister(0), i.InputRegister(1));  \
 207       } else {                                                 \
 208         __ asm_instr(i.InputRegister(0), i.InputOperand(1));   \
 209       }                                                        \
 210     }                                                          \
 211   } while (0)
 212
 213
 214 #define ASSEMBLE_MULT(asm_instr)                              \
 215   do {                                                        \
 216     if (HasImmediateInput(instr, 1)) {                        \
 217       if (instr->InputAt(0)->IsRegister()) {                  \
 218         __ asm_instr(i.OutputRegister(), i.InputRegister(0),  \
 219                      i.InputImmediate(1));                    \
 220       } else {                                                \
 221         __ asm_instr(i.OutputRegister(), i.InputOperand(0),   \
 222                      i.InputImmediate(1));                    \
 223       }                                                       \
 224     } else {                                                  \
 225       if (instr->InputAt(1)->IsRegister()) {                  \
 226         __ asm_instr(i.OutputRegister(), i.InputRegister(1)); \
 227       } else {                                                \
 228         __ asm_instr(i.OutputRegister(), i.InputOperand(1));  \
 229       }                                                       \
 230     }                                                         \
 231   } while (0)
 232
 233
 234 #define ASSEMBLE_SHIFT(asm_instr, width)                                   \
 235   do {                                                                     \
 236     if (HasImmediateInput(instr, 1)) {                                     \
 237       if (instr->Output()->IsRegister()) {                                 \
 238         __ asm_instr(i.OutputRegister(), Immediate(i.InputInt##width(1))); \
 239       } else {                                                             \
 240         __ asm_instr(i.OutputOperand(), Immediate(i.InputInt##width(1)));  \
 241       }                                                                    \
 242     } else {                                                               \
 243       if (instr->Output()->IsRegister()) {                                 \
 244         __ asm_instr##_cl(i.OutputRegister());                             \
 245       } else {                                                             \
 246         __ asm_instr##_cl(i.OutputOperand());                              \
 247       }                                                                    \
 248     }                                                                      \
 249   } while (0)
 250
 251
 252 #define ASSEMBLE_DOUBLE_BINOP(asm_instr)                                \
 253   do {                                                                  \
 254     if (instr->InputAt(1)->IsDoubleRegister()) {                        \
 255       __ asm_instr(i.InputDoubleRegister(0), i.InputDoubleRegister(1)); \
 256     } else {                                                            \
 257       __ asm_instr(i.InputDoubleRegister(0), i.InputOperand(1));        \
 258     }                                                                   \
 259   } while (0)
 260
 261
 262 #define ASSEMBLE_AVX_DOUBLE_BINOP(asm_instr)                           \
 263   do {                                                                 \
 264     CpuFeatureScope avx_scope(masm(), AVX);                            \
 265     if (instr->InputAt(1)->IsDoubleRegister()) {                       \
 266       __ asm_instr(i.OutputDoubleRegister(), i.InputDoubleRegister(0), \
 267                    i.InputDoubleRegister(1));                          \
 268     } else {                                                           \
 269       __ asm_instr(i.OutputDoubleRegister(), i.InputDoubleRegister(0), \
 270                    i.InputOperand(1));                                 \
 271     }                                                                  \
 272   } while (0)
 273
 274
 275 #define ASSEMBLE_CHECKED_LOAD_FLOAT(asm_instr)                          \
 276   do {                                                                  \
 277     auto result = i.OutputDoubleRegister();                             \
 278     auto offset = i.InputRegister(0);                                   \
 279     if (instr->InputAt(1)->IsRegister()) {                              \
 280       __ cmpl(offset, i.InputRegister(1));                              \
 281     } else {                                                            \
 282       __ cmpl(offset, i.InputImmediate(1));                             \
 283     }                                                                   \
 284     OutOfLineCode* ool = new (zone()) OutOfLineLoadFloat(this, result); \
 285     __ j(above_equal, ool->entry());                                    \
 286     __ asm_instr(result, i.MemoryOperand(2));                           \
 287     __ bind(ool->exit());                                               \
 288   } while (false)
 289
 290
 291 #define ASSEMBLE_CHECKED_LOAD_INTEGER(asm_instr)                          \
 292   do {                                                                    \
 293     auto result = i.OutputRegister();                                     \
 294     auto offset = i.InputRegister(0);                                     \
 295     if (instr->InputAt(1)->IsRegister()) {                                \
 296       __ cmpl(offset, i.InputRegister(1));                                \
 297     } else {                                                              \
 298       __ cmpl(offset, i.InputImmediate(1));                               \
 299     }                                                                     \
 300     OutOfLineCode* ool = new (zone()) OutOfLineLoadInteger(this, result); \
 301     __ j(above_equal, ool->entry());                                      \
 302     __ asm_instr(result, i.MemoryOperand(2));                             \
 303     __ bind(ool->exit());                                                 \
 304   } while (false)
 305
 306
 307 #define ASSEMBLE_CHECKED_STORE_FLOAT(asm_instr)                 \
 308   do {                                                          \
 309     auto offset = i.InputRegister(0);                           \
 310     if (instr->InputAt(1)->IsRegister()) {                      \
 311       __ cmpl(offset, i.InputRegister(1));                      \
 312     } else {                                                    \
 313       __ cmpl(offset, i.InputImmediate(1));                     \
 314     }                                                           \
 315     Label done;                                                 \
 316     __ j(above_equal, &done, Label::kNear);                     \
 317     __ asm_instr(i.MemoryOperand(3), i.InputDoubleRegister(2)); \
 318     __ bind(&done);                                             \
 319   } while (false)
 320
 321
 322 #define ASSEMBLE_CHECKED_STORE_INTEGER(asm_instr)            \
 323   do {                                                       \
 324     auto offset = i.InputRegister(0);                        \
 325     if (instr->InputAt(1)->IsRegister()) {                   \
 326       __ cmpl(offset, i.InputRegister(1));                   \
 327     } else {                                                 \
 328       __ cmpl(offset, i.InputImmediate(1));                  \
 329     }                                                        \
 330     Label done;                                              \
 331     __ j(above_equal, &done, Label::kNear);                  \
 332     if (instr->InputAt(2)->IsRegister()) {                   \
 333       __ asm_instr(i.MemoryOperand(3), i.InputRegister(2));  \
 334     } else {                                                 \
 335       __ asm_instr(i.MemoryOperand(3), i.InputImmediate(2)); \
 336     }                                                        \
 337     __ bind(&done);                                          \
 338   } while (false)
 339
 340
 341 // Assembles an instruction after register allocation, producing machine code.
 342 void CodeGenerator::AssembleArchInstruction(Instruction* instr) {
 343   X64OperandConverter i(this, instr);
 344
 345   switch (ArchOpcodeField::decode(instr->opcode())) {
 346     case kArchCallCodeObject: {
 347       EnsureSpaceForLazyDeopt();
 348       if (HasImmediateInput(instr, 0)) {
 349         Handle<Code> code = Handle<Code>::cast(i.InputHeapObject(0));
 350         __ Call(code, RelocInfo::CODE_TARGET);
 351       } else {
 352         Register reg = i.InputRegister(0);
 353         int entry = Code::kHeaderSize - kHeapObjectTag;
 354         __ Call(Operand(reg, entry));
 355       }
 356       AddSafepointAndDeopt(instr);
 357       break;
 358     }
 359     case kArchCallJSFunction: {
 360       EnsureSpaceForLazyDeopt();
 361       Register func = i.InputRegister(0);
 362       if (FLAG_debug_code) {
 363         // Check the function's context matches the context argument.
 364         __ cmpp(rsi, FieldOperand(func, JSFunction::kContextOffset));
 365         __ Assert(equal, kWrongFunctionContext);
 366       }
 367       __ Call(FieldOperand(func, JSFunction::kCodeEntryOffset));
 368       AddSafepointAndDeopt(instr);
 369       break;
 370     }
 371     case kArchJmp:
 372       AssembleArchJump(i.InputRpo(0));
 373       break;
 374     case kArchNop:
 375       // don't emit code for nops.
 376       break;
 377     case kArchRet:
 378       AssembleReturn();
 379       break;
 380     case kArchStackPointer:
 381       __ movq(i.OutputRegister(), rsp);
 382       break;
 383     case kArchTruncateDoubleToI: {
 384       auto result = i.OutputRegister();
 385       auto input = i.InputDoubleRegister(0);
 386       auto ool = new (zone()) OutOfLineTruncateDoubleToI(this, result, input);
 387       __ cvttsd2siq(result, input);
 388       __ cmpq(result, Immediate(1));
 389       __ j(overflow, ool->entry());
 390       __ bind(ool->exit());
 391       break;
 392     }
 393     case kX64Add32:
 394       ASSEMBLE_BINOP(addl);
 395       break;
 396     case kX64Add:
 397       ASSEMBLE_BINOP(addq);
 398       break;
 399     case kX64Sub32:
 400       ASSEMBLE_BINOP(subl);
 401       break;
 402     case kX64Sub:
 403       ASSEMBLE_BINOP(subq);
 404       break;
 405     case kX64And32:
 406       ASSEMBLE_BINOP(andl);
 407       break;
 408     case kX64And:
 409       ASSEMBLE_BINOP(andq);
 410       break;
 411     case kX64Cmp32:
 412       ASSEMBLE_BINOP(cmpl);
 413       break;
 414     case kX64Cmp:
 415       ASSEMBLE_BINOP(cmpq);
 416       break;
 417     case kX64Test32:
 418       ASSEMBLE_BINOP(testl);
 419       break;
 420     case kX64Test:
 421       ASSEMBLE_BINOP(testq);
 422       break;
 423     case kX64Imul32:
 424       ASSEMBLE_MULT(imull);
 425       break;
 426     case kX64Imul:
 427       ASSEMBLE_MULT(imulq);
 428       break;
 429     case kX64ImulHigh32:
 430       if (instr->InputAt(1)->IsRegister()) {
 431         __ imull(i.InputRegister(1));
 432       } else {
 433         __ imull(i.InputOperand(1));
 434       }
 435       break;
 436     case kX64UmulHigh32:
 437       if (instr->InputAt(1)->IsRegister()) {
 438         __ mull(i.InputRegister(1));
 439       } else {
 440         __ mull(i.InputOperand(1));
 441       }
 442       break;
 443     case kX64Idiv32:
 444       __ cdq();
 445       __ idivl(i.InputRegister(1));
 446       break;
 447     case kX64Idiv:
 448       __ cqo();
 449       __ idivq(i.InputRegister(1));
 450       break;
 451     case kX64Udiv32:
 452       __ xorl(rdx, rdx);
 453       __ divl(i.InputRegister(1));
 454       break;
 455     case kX64Udiv:
 456       __ xorq(rdx, rdx);
 457       __ divq(i.InputRegister(1));
 458       break;
 459     case kX64Not:
 460       ASSEMBLE_UNOP(notq);
 461       break;
 462     case kX64Not32:
 463       ASSEMBLE_UNOP(notl);
 464       break;
 465     case kX64Neg:
 466       ASSEMBLE_UNOP(negq);
 467       break;
 468     case kX64Neg32:
 469       ASSEMBLE_UNOP(negl);
 470       break;
 471     case kX64Or32:
 472       ASSEMBLE_BINOP(orl);
 473       break;
 474     case kX64Or:
 475       ASSEMBLE_BINOP(orq);
 476       break;
 477     case kX64Xor32:
 478       ASSEMBLE_BINOP(xorl);
 479       break;
 480     case kX64Xor:
 481       ASSEMBLE_BINOP(xorq);
 482       break;
 483     case kX64Shl32:
 484       ASSEMBLE_SHIFT(shll, 5);
 485       break;
 486     case kX64Shl:
 487       ASSEMBLE_SHIFT(shlq, 6);
 488       break;
 489     case kX64Shr32:
 490       ASSEMBLE_SHIFT(shrl, 5);
 491       break;
 492     case kX64Shr:
 493       ASSEMBLE_SHIFT(shrq, 6);
 494       break;
 495     case kX64Sar32:
 496       ASSEMBLE_SHIFT(sarl, 5);
 497       break;
 498     case kX64Sar:
 499       ASSEMBLE_SHIFT(sarq, 6);
 500       break;
 501     case kX64Ror32:
 502       ASSEMBLE_SHIFT(rorl, 5);
 503       break;
 504     case kX64Ror:
 505       ASSEMBLE_SHIFT(rorq, 6);
 506       break;
 507     case kSSEFloat64Cmp:
 508       ASSEMBLE_DOUBLE_BINOP(ucomisd);
 509       break;
 510     case kSSEFloat64Add:
 511       ASSEMBLE_DOUBLE_BINOP(addsd);
 512       break;
 513     case kSSEFloat64Sub:
 514       ASSEMBLE_DOUBLE_BINOP(subsd);
 515       break;
 516     case kSSEFloat64Mul:
 517       ASSEMBLE_DOUBLE_BINOP(mulsd);
 518       break;
 519     case kSSEFloat64Div:
 520       ASSEMBLE_DOUBLE_BINOP(divsd);
 521       break;
 522     case kSSEFloat64Mod: {
 523       __ subq(rsp, Immediate(kDoubleSize));
 524       // Move values to st(0) and st(1).
 525       __ movsd(Operand(rsp, 0), i.InputDoubleRegister(1));
 526       __ fld_d(Operand(rsp, 0));
 527       __ movsd(Operand(rsp, 0), i.InputDoubleRegister(0));
 528       __ fld_d(Operand(rsp, 0));
 529       // Loop while fprem isn't done.
 530       Label mod_loop;
 531       __ bind(&mod_loop);
 532       // This instructions traps on all kinds inputs, but we are assuming the
 533       // floating point control word is set to ignore them all.
 534       __ fprem();
 535       // The following 2 instruction implicitly use rax.
 536       __ fnstsw_ax();
 537       if (CpuFeatures::IsSupported(SAHF)) {
 538         CpuFeatureScope sahf_scope(masm(), SAHF);
 539         __ sahf();
 540       } else {
 541         __ shrl(rax, Immediate(8));
 542         __ andl(rax, Immediate(0xFF));
 543         __ pushq(rax);
 544         __ popfq();
 545       }
 546       __ j(parity_even, &mod_loop);
 547       // Move output to stack and clean up.
 548       __ fstp(1);
 549       __ fstp_d(Operand(rsp, 0));
 550       __ movsd(i.OutputDoubleRegister(), Operand(rsp, 0));
 551       __ addq(rsp, Immediate(kDoubleSize));
 552       break;
 553     }
 554     case kSSEFloat64Sqrt:
 555       if (instr->InputAt(0)->IsDoubleRegister()) {
 556         __ sqrtsd(i.OutputDoubleRegister(), i.InputDoubleRegister(0));
 557       } else {
 558         __ sqrtsd(i.OutputDoubleRegister(), i.InputOperand(0));
 559       }
 560       break;
 561     case kSSEFloat64Floor: {
 562       CpuFeatureScope sse_scope(masm(), SSE4_1);
 563       __ roundsd(i.OutputDoubleRegister(), i.InputDoubleRegister(0),
 564                  v8::internal::Assembler::kRoundDown);
 565       break;
 566     }
 567     case kSSEFloat64Ceil: {
 568       CpuFeatureScope sse_scope(masm(), SSE4_1);
 569       __ roundsd(i.OutputDoubleRegister(), i.InputDoubleRegister(0),
 570                  v8::internal::Assembler::kRoundUp);
 571       break;
 572     }
 573     case kSSEFloat64RoundTruncate: {
 574       CpuFeatureScope sse_scope(masm(), SSE4_1);
 575       __ roundsd(i.OutputDoubleRegister(), i.InputDoubleRegister(0),
 576                  v8::internal::Assembler::kRoundToZero);
 577       break;
 578     }
 579     case kSSECvtss2sd:
 580       if (instr->InputAt(0)->IsDoubleRegister()) {
 581         __ cvtss2sd(i.OutputDoubleRegister(), i.InputDoubleRegister(0));
 582       } else {
 583         __ cvtss2sd(i.OutputDoubleRegister(), i.InputOperand(0));
 584       }
 585       break;
 586     case kSSECvtsd2ss:
 587       if (instr->InputAt(0)->IsDoubleRegister()) {
 588         __ cvtsd2ss(i.OutputDoubleRegister(), i.InputDoubleRegister(0));
 589       } else {
 590         __ cvtsd2ss(i.OutputDoubleRegister(), i.InputOperand(0));
 591       }
 592       break;
 593     case kSSEFloat64ToInt32:
 594       if (instr->InputAt(0)->IsDoubleRegister()) {
 595         __ cvttsd2si(i.OutputRegister(), i.InputDoubleRegister(0));
 596       } else {
 597         __ cvttsd2si(i.OutputRegister(), i.InputOperand(0));
 598       }
 599       break;
 600     case kSSEFloat64ToUint32: {
 601       if (instr->InputAt(0)->IsDoubleRegister()) {
 602         __ cvttsd2siq(i.OutputRegister(), i.InputDoubleRegister(0));
 603       } else {
 604         __ cvttsd2siq(i.OutputRegister(), i.InputOperand(0));
 605       }
 606       __ AssertZeroExtended(i.OutputRegister());
 607       break;
 608     }
 609     case kSSEInt32ToFloat64:
 610       if (instr->InputAt(0)->IsRegister()) {
 611         __ cvtlsi2sd(i.OutputDoubleRegister(), i.InputRegister(0));
 612       } else {
 613         __ cvtlsi2sd(i.OutputDoubleRegister(), i.InputOperand(0));
 614       }
 615       break;
 616     case kSSEUint32ToFloat64:
 617       if (instr->InputAt(0)->IsRegister()) {
 618         __ movl(kScratchRegister, i.InputRegister(0));
 619       } else {
 620         __ movl(kScratchRegister, i.InputOperand(0));
 621       }
 622       __ cvtqsi2sd(i.OutputDoubleRegister(), kScratchRegister);
 623       break;
 624     case kAVXFloat64Add:
 625       ASSEMBLE_AVX_DOUBLE_BINOP(vaddsd);
 626       break;
 627     case kAVXFloat64Sub:
 628       ASSEMBLE_AVX_DOUBLE_BINOP(vsubsd);
 629       break;
 630     case kAVXFloat64Mul:
 631       ASSEMBLE_AVX_DOUBLE_BINOP(vmulsd);
 632       break;
 633     case kAVXFloat64Div:
 634       ASSEMBLE_AVX_DOUBLE_BINOP(vdivsd);
 635       break;
 636     case kX64Movsxbl:
 637       if (instr->addressing_mode() != kMode_None) {
 638         __ movsxbl(i.OutputRegister(), i.MemoryOperand());
 639       } else if (instr->InputAt(0)->IsRegister()) {
 640         __ movsxbl(i.OutputRegister(), i.InputRegister(0));
 641       } else {
 642         __ movsxbl(i.OutputRegister(), i.InputOperand(0));
 643       }
 644       __ AssertZeroExtended(i.OutputRegister());
 645       break;
 646     case kX64Movzxbl:
 647       __ movzxbl(i.OutputRegister(), i.MemoryOperand());
 648       break;
 649     case kX64Movb: {
 650       int index = 0;
 651       Operand operand = i.MemoryOperand(&index);
 652       if (HasImmediateInput(instr, index)) {
 653         __ movb(operand, Immediate(i.InputInt8(index)));
 654       } else {
 655         __ movb(operand, i.InputRegister(index));
 656       }
 657       break;
 658     }
 659     case kX64Movsxwl:
 660       if (instr->addressing_mode() != kMode_None) {
 661         __ movsxwl(i.OutputRegister(), i.MemoryOperand());
 662       } else if (instr->InputAt(0)->IsRegister()) {
 663         __ movsxwl(i.OutputRegister(), i.InputRegister(0));
 664       } else {
 665         __ movsxwl(i.OutputRegister(), i.InputOperand(0));
 666       }
 667       __ AssertZeroExtended(i.OutputRegister());
 668       break;
 669     case kX64Movzxwl:
 670       __ movzxwl(i.OutputRegister(), i.MemoryOperand());
 671       __ AssertZeroExtended(i.OutputRegister());
 672       break;
 673     case kX64Movw: {
 674       int index = 0;
 675       Operand operand = i.MemoryOperand(&index);
 676       if (HasImmediateInput(instr, index)) {
 677         __ movw(operand, Immediate(i.InputInt16(index)));
 678       } else {
 679         __ movw(operand, i.InputRegister(index));
 680       }
 681       break;
 682     }
 683     case kX64Movl:
 684       if (instr->HasOutput()) {
 685         if (instr->addressing_mode() == kMode_None) {
 686           if (instr->InputAt(0)->IsRegister()) {
 687             __ movl(i.OutputRegister(), i.InputRegister(0));
 688           } else {
 689             __ movl(i.OutputRegister(), i.InputOperand(0));
 690           }
 691         } else {
 692           __ movl(i.OutputRegister(), i.MemoryOperand());
 693         }
 694         __ AssertZeroExtended(i.OutputRegister());
 695       } else {
 696         int index = 0;
 697         Operand operand = i.MemoryOperand(&index);
 698         if (HasImmediateInput(instr, index)) {
 699           __ movl(operand, i.InputImmediate(index));
 700         } else {
 701           __ movl(operand, i.InputRegister(index));
 702         }
 703       }
 704       break;
 705     case kX64Movsxlq: {
 706       if (instr->InputAt(0)->IsRegister()) {
 707         __ movsxlq(i.OutputRegister(), i.InputRegister(0));
 708       } else {
 709         __ movsxlq(i.OutputRegister(), i.InputOperand(0));
 710       }
 711       break;
 712     }
 713     case kX64Movq:
 714       if (instr->HasOutput()) {
 715         __ movq(i.OutputRegister(), i.MemoryOperand());
 716       } else {
 717         int index = 0;
 718         Operand operand = i.MemoryOperand(&index);
 719         if (HasImmediateInput(instr, index)) {
 720           __ movq(operand, i.InputImmediate(index));
 721         } else {
 722           __ movq(operand, i.InputRegister(index));
 723         }
 724       }
 725       break;
 726     case kX64Movss:
 727       if (instr->HasOutput()) {
 728         __ movss(i.OutputDoubleRegister(), i.MemoryOperand());
 729       } else {
 730         int index = 0;
 731         Operand operand = i.MemoryOperand(&index);
 732         __ movss(operand, i.InputDoubleRegister(index));
 733       }
 734       break;
 735     case kX64Movsd:
 736       if (instr->HasOutput()) {
 737         __ movsd(i.OutputDoubleRegister(), i.MemoryOperand());
 738       } else {
 739         int index = 0;
 740         Operand operand = i.MemoryOperand(&index);
 741         __ movsd(operand, i.InputDoubleRegister(index));
 742       }
 743       break;
 744     case kX64Lea32: {
 745       AddressingMode mode = AddressingModeField::decode(instr->opcode());
 746       // Shorten "leal" to "addl", "subl" or "shll" if the register allocation
 747       // and addressing mode just happens to work out. The "addl"/"subl" forms
 748       // in these cases are faster based on measurements.
 749       if (i.InputRegister(0).is(i.OutputRegister())) {
 750         if (mode == kMode_MRI) {
 751           int32_t constant_summand = i.InputInt32(1);
 752           if (constant_summand > 0) {
 753             __ addl(i.OutputRegister(), Immediate(constant_summand));
 754           } else if (constant_summand < 0) {
 755             __ subl(i.OutputRegister(), Immediate(-constant_summand));
 756           }
 757         } else if (mode == kMode_MR1 || mode == kMode_M2) {
 758           // Using "addl %r1, %r1" is generally faster than "shll %r1, 1"
 759           __ addl(i.OutputRegister(), i.InputRegister(1));
 760         } else if (mode == kMode_M4) {
 761           __ shll(i.OutputRegister(), Immediate(2));
 762         } else if (mode == kMode_M8) {
 763           __ shll(i.OutputRegister(), Immediate(3));
 764         } else {
 765           __ leal(i.OutputRegister(), i.MemoryOperand());
 766         }
 767       } else {
 768         __ leal(i.OutputRegister(), i.MemoryOperand());
 769       }
 770       __ AssertZeroExtended(i.OutputRegister());
 771       break;
 772     }
 773     case kX64Lea:
 774       __ leaq(i.OutputRegister(), i.MemoryOperand());
 775       break;
 776     case kX64Dec32:
 777       __ decl(i.OutputRegister());
 778       break;
 779     case kX64Inc32:
 780       __ incl(i.OutputRegister());
 781       break;
 782     case kX64Push:
 783       if (HasImmediateInput(instr, 0)) {
 784         __ pushq(i.InputImmediate(0));
 785       } else {
 786         if (instr->InputAt(0)->IsRegister()) {
 787           __ pushq(i.InputRegister(0));
 788         } else {
 789           __ pushq(i.InputOperand(0));
 790         }
 791       }
 792       break;
 793     case kX64StoreWriteBarrier: {
 794       Register object = i.InputRegister(0);
 795       Register index = i.InputRegister(1);
 796       Register value = i.InputRegister(2);
 797       __ movsxlq(index, index);
 798       __ movq(Operand(object, index, times_1, 0), value);
 799       __ leaq(index, Operand(object, index, times_1, 0));
 800       SaveFPRegsMode mode =
 801           frame()->DidAllocateDoubleRegisters() ? kSaveFPRegs : kDontSaveFPRegs;
 802       __ RecordWrite(object, index, value, mode);
 803       break;
 804     }
 805     case kCheckedLoadInt8:
 806       ASSEMBLE_CHECKED_LOAD_INTEGER(movsxbl);
 807       break;
 808     case kCheckedLoadUint8:
 809       ASSEMBLE_CHECKED_LOAD_INTEGER(movzxbl);
 810       break;
 811     case kCheckedLoadInt16:
 812       ASSEMBLE_CHECKED_LOAD_INTEGER(movsxwl);
 813       break;
 814     case kCheckedLoadUint16:
 815       ASSEMBLE_CHECKED_LOAD_INTEGER(movzxwl);
 816       break;
 817     case kCheckedLoadWord32:
 818       ASSEMBLE_CHECKED_LOAD_INTEGER(movl);
 819       break;
 820     case kCheckedLoadFloat32:
 821       ASSEMBLE_CHECKED_LOAD_FLOAT(movss);
 822       break;
 823     case kCheckedLoadFloat64:
 824       ASSEMBLE_CHECKED_LOAD_FLOAT(movsd);
 825       break;
 826     case kCheckedStoreWord8:
 827       ASSEMBLE_CHECKED_STORE_INTEGER(movb);
 828       break;
 829     case kCheckedStoreWord16:
 830       ASSEMBLE_CHECKED_STORE_INTEGER(movw);
 831       break;
 832     case kCheckedStoreWord32:
 833       ASSEMBLE_CHECKED_STORE_INTEGER(movl);
 834       break;
 835     case kCheckedStoreFloat32:
 836       ASSEMBLE_CHECKED_STORE_FLOAT(movss);
 837       break;
 838     case kCheckedStoreFloat64:
 839       ASSEMBLE_CHECKED_STORE_FLOAT(movsd);
 840       break;
 841   }
 842 }
 843
 844
 845 // Assembles branches after this instruction.
 846 void CodeGenerator::AssembleArchBranch(Instruction* instr, BranchInfo* branch) {
 847   X64OperandConverter i(this, instr);
 848   Label::Distance flabel_distance =
 849       branch->fallthru ? Label::kNear : Label::kFar;
 850   Label* tlabel = branch->true_label;
 851   Label* flabel = branch->false_label;
 852   switch (branch->condition) {
 853     case kUnorderedEqual:
 854       __ j(parity_even, flabel, flabel_distance);
 855     // Fall through.
 856     case kEqual:
 857       __ j(equal, tlabel);
 858       break;
 859     case kUnorderedNotEqual:
 860       __ j(parity_even, tlabel);
 861     // Fall through.
 862     case kNotEqual:
 863       __ j(not_equal, tlabel);
 864       break;
 865     case kSignedLessThan:
 866       __ j(less, tlabel);
 867       break;
 868     case kSignedGreaterThanOrEqual:
 869       __ j(greater_equal, tlabel);
 870       break;
 871     case kSignedLessThanOrEqual:
 872       __ j(less_equal, tlabel);
 873       break;
 874     case kSignedGreaterThan:
 875       __ j(greater, tlabel);
 876       break;
 877     case kUnorderedLessThan:
 878       __ j(parity_even, flabel, flabel_distance);
 879     // Fall through.
 880     case kUnsignedLessThan:
 881       __ j(below, tlabel);
 882       break;
 883     case kUnorderedGreaterThanOrEqual:
 884       __ j(parity_even, tlabel);
 885     // Fall through.
 886     case kUnsignedGreaterThanOrEqual:
 887       __ j(above_equal, tlabel);
 888       break;
 889     case kUnorderedLessThanOrEqual:
 890       __ j(parity_even, flabel, flabel_distance);
 891     // Fall through.
 892     case kUnsignedLessThanOrEqual:
 893       __ j(below_equal, tlabel);
 894       break;
 895     case kUnorderedGreaterThan:
 896       __ j(parity_even, tlabel);
 897     // Fall through.
 898     case kUnsignedGreaterThan:
 899       __ j(above, tlabel);
 900       break;
 901     case kOverflow:
 902       __ j(overflow, tlabel);
 903       break;
 904     case kNotOverflow:
 905       __ j(no_overflow, tlabel);
 906       break;
 907   }
 908   if (!branch->fallthru) __ jmp(flabel, flabel_distance);
 909 }
 910
 911
 912 void CodeGenerator::AssembleArchJump(BasicBlock::RpoNumber target) {
 913   if (!IsNextInAssemblyOrder(target)) __ jmp(GetLabel(target));
 914 }
 915
 916
 917 // Assembles boolean materializations after this instruction.
 918 void CodeGenerator::AssembleArchBoolean(Instruction* instr,
 919                                         FlagsCondition condition) {
 920   X64OperandConverter i(this, instr);
 921   Label done;
 922
 923   // Materialize a full 64-bit 1 or 0 value. The result register is always the
 924   // last output of the instruction.
 925   Label check;
 926   DCHECK_NE(0, static_cast<int>(instr->OutputCount()));
 927   Register reg = i.OutputRegister(static_cast<int>(instr->OutputCount() - 1));
 928   Condition cc = no_condition;
 929   switch (condition) {
 930     case kUnorderedEqual:
 931       __ j(parity_odd, &check, Label::kNear);
 932       __ movl(reg, Immediate(0));
 933       __ jmp(&done, Label::kNear);
 934     // Fall through.
 935     case kEqual:
 936       cc = equal;
 937       break;
 938     case kUnorderedNotEqual:
 939       __ j(parity_odd, &check, Label::kNear);
 940       __ movl(reg, Immediate(1));
 941       __ jmp(&done, Label::kNear);
 942     // Fall through.
 943     case kNotEqual:
 944       cc = not_equal;
 945       break;
 946     case kSignedLessThan:
 947       cc = less;
 948       break;
 949     case kSignedGreaterThanOrEqual:
 950       cc = greater_equal;
 951       break;
 952     case kSignedLessThanOrEqual:
 953       cc = less_equal;
 954       break;
 955     case kSignedGreaterThan:
 956       cc = greater;
 957       break;
 958     case kUnorderedLessThan:
 959       __ j(parity_odd, &check, Label::kNear);
 960       __ movl(reg, Immediate(0));
 961       __ jmp(&done, Label::kNear);
 962     // Fall through.
 963     case kUnsignedLessThan:
 964       cc = below;
 965       break;
 966     case kUnorderedGreaterThanOrEqual:
 967       __ j(parity_odd, &check, Label::kNear);
 968       __ movl(reg, Immediate(1));
 969       __ jmp(&done, Label::kNear);
 970     // Fall through.
 971     case kUnsignedGreaterThanOrEqual:
 972       cc = above_equal;
 973       break;
 974     case kUnorderedLessThanOrEqual:
 975       __ j(parity_odd, &check, Label::kNear);
 976       __ movl(reg, Immediate(0));
 977       __ jmp(&done, Label::kNear);
 978     // Fall through.
 979     case kUnsignedLessThanOrEqual:
 980       cc = below_equal;
 981       break;
 982     case kUnorderedGreaterThan:
 983       __ j(parity_odd, &check, Label::kNear);
 984       __ movl(reg, Immediate(1));
 985       __ jmp(&done, Label::kNear);
 986     // Fall through.
 987     case kUnsignedGreaterThan:
 988       cc = above;
 989       break;
 990     case kOverflow:
 991       cc = overflow;
 992       break;
 993     case kNotOverflow:
 994       cc = no_overflow;
 995       break;
 996   }
 997   __ bind(&check);
 998   __ setcc(cc, reg);
 999   __ movzxbl(reg, reg);
1000   __ bind(&done);
1001 }
1002
1003
1004 void CodeGenerator::AssembleDeoptimizerCall(int deoptimization_id) {
1005   Address deopt_entry = Deoptimizer::GetDeoptimizationEntry(
1006       isolate(), deoptimization_id, Deoptimizer::LAZY);
1007   __ call(deopt_entry, RelocInfo::RUNTIME_ENTRY);
1008 }
1009
1010
1011 void CodeGenerator::AssemblePrologue() {
1012   CallDescriptor* descriptor = linkage()->GetIncomingDescriptor();
1013   int stack_slots = frame()->GetSpillSlotCount();
1014   if (descriptor->kind() == CallDescriptor::kCallAddress) {
1015     __ pushq(rbp);
1016     __ movq(rbp, rsp);
1017     const RegList saves = descriptor->CalleeSavedRegisters();
1018     if (saves != 0) {  // Save callee-saved registers.
1019       int register_save_area_size = 0;
1020       for (int i = Register::kNumRegisters - 1; i >= 0; i--) {
1021         if (!((1 << i) & saves)) continue;
1022         __ pushq(Register::from_code(i));
1023         register_save_area_size += kPointerSize;
1024       }
1025       frame()->SetRegisterSaveAreaSize(register_save_area_size);
1026     }
1027   } else if (descriptor->IsJSFunctionCall()) {
1028     CompilationInfo* info = this->info();
1029     __ Prologue(info->IsCodePreAgingActive());
1030     frame()->SetRegisterSaveAreaSize(
1031         StandardFrameConstants::kFixedFrameSizeFromFp);
1032   } else {
1033     __ StubPrologue();
1034     frame()->SetRegisterSaveAreaSize(
1035         StandardFrameConstants::kFixedFrameSizeFromFp);
1036   }
1037   if (stack_slots > 0) {
1038     __ subq(rsp, Immediate(stack_slots * kPointerSize));
1039   }
1040 }
1041
1042
1043 void CodeGenerator::AssembleReturn() {
1044   CallDescriptor* descriptor = linkage()->GetIncomingDescriptor();
1045   if (descriptor->kind() == CallDescriptor::kCallAddress) {
1046     if (frame()->GetRegisterSaveAreaSize() > 0) {
1047       // Remove this frame's spill slots first.
1048       int stack_slots = frame()->GetSpillSlotCount();
1049       if (stack_slots > 0) {
1050         __ addq(rsp, Immediate(stack_slots * kPointerSize));
1051       }
1052       const RegList saves = descriptor->CalleeSavedRegisters();
1053       // Restore registers.
1054       if (saves != 0) {
1055         for (int i = 0; i < Register::kNumRegisters; i++) {
1056           if (!((1 << i) & saves)) continue;
1057           __ popq(Register::from_code(i));
1058         }
1059       }
1060       __ popq(rbp);  // Pop caller's frame pointer.
1061       __ ret(0);
1062     } else {
1063       // No saved registers.
1064       __ movq(rsp, rbp);  // Move stack pointer back to frame pointer.
1065       __ popq(rbp);       // Pop caller's frame pointer.
1066       __ ret(0);
1067     }
1068   } else {
1069     __ movq(rsp, rbp);  // Move stack pointer back to frame pointer.
1070     __ popq(rbp);       // Pop caller's frame pointer.
1071     int pop_count = descriptor->IsJSFunctionCall()
1072                         ? static_cast<int>(descriptor->JSParameterCount())
1073                         : 0;
1074     __ ret(pop_count * kPointerSize);
1075   }
1076 }
1077
1078
1079 void CodeGenerator::AssembleMove(InstructionOperand* source,
1080                                  InstructionOperand* destination) {
1081   X64OperandConverter g(this, NULL);
1082   // Dispatch on the source and destination operand kinds.  Not all
1083   // combinations are possible.
1084   if (source->IsRegister()) {
1085     DCHECK(destination->IsRegister() || destination->IsStackSlot());
1086     Register src = g.ToRegister(source);
1087     if (destination->IsRegister()) {
1088       __ movq(g.ToRegister(destination), src);
1089     } else {
1090       __ movq(g.ToOperand(destination), src);
1091     }
1092   } else if (source->IsStackSlot()) {
1093     DCHECK(destination->IsRegister() || destination->IsStackSlot());
1094     Operand src = g.ToOperand(source);
1095     if (destination->IsRegister()) {
1096       Register dst = g.ToRegister(destination);
1097       __ movq(dst, src);
1098     } else {
1099       // Spill on demand to use a temporary register for memory-to-memory
1100       // moves.
1101       Register tmp = kScratchRegister;
1102       Operand dst = g.ToOperand(destination);
1103       __ movq(tmp, src);
1104       __ movq(dst, tmp);
1105     }
1106   } else if (source->IsConstant()) {
1107     ConstantOperand* constant_source = ConstantOperand::cast(source);
1108     Constant src = g.ToConstant(constant_source);
1109     if (destination->IsRegister() || destination->IsStackSlot()) {
1110       Register dst = destination->IsRegister() ? g.ToRegister(destination)
1111                                                : kScratchRegister;
1112       switch (src.type()) {
1113         case Constant::kInt32:
1114           // TODO(dcarney): don't need scratch in this case.
1115           __ Set(dst, src.ToInt32());
1116           break;
1117         case Constant::kInt64:
1118           __ Set(dst, src.ToInt64());
1119           break;
1120         case Constant::kFloat32:
1121           __ Move(dst,
1122                   isolate()->factory()->NewNumber(src.ToFloat32(), TENURED));
1123           break;
1124         case Constant::kFloat64:
1125           __ Move(dst,
1126                   isolate()->factory()->NewNumber(src.ToFloat64(), TENURED));
1127           break;
1128         case Constant::kExternalReference:
1129           __ Move(dst, src.ToExternalReference());
1130           break;
1131         case Constant::kHeapObject:
1132           __ Move(dst, src.ToHeapObject());
1133           break;
1134         case Constant::kRpoNumber:
1135           UNREACHABLE();  // TODO(dcarney): load of labels on x64.
1136           break;
1137       }
1138       if (destination->IsStackSlot()) {
1139         __ movq(g.ToOperand(destination), kScratchRegister);
1140       }
1141     } else if (src.type() == Constant::kFloat32) {
1142       // TODO(turbofan): Can we do better here?
1143       uint32_t src_const = bit_cast<uint32_t>(src.ToFloat32());
1144       if (destination->IsDoubleRegister()) {
1145         __ Move(g.ToDoubleRegister(destination), src_const);
1146       } else {
1147         DCHECK(destination->IsDoubleStackSlot());
1148         Operand dst = g.ToOperand(destination);
1149         __ movl(dst, Immediate(src_const));
1150       }
1151     } else {
1152       DCHECK_EQ(Constant::kFloat64, src.type());
1153       uint64_t src_const = bit_cast<uint64_t>(src.ToFloat64());
1154       if (destination->IsDoubleRegister()) {
1155         __ Move(g.ToDoubleRegister(destination), src_const);
1156       } else {
1157         DCHECK(destination->IsDoubleStackSlot());
1158         __ movq(kScratchRegister, src_const);
1159         __ movq(g.ToOperand(destination), kScratchRegister);
1160       }
1161     }
1162   } else if (source->IsDoubleRegister()) {
1163     XMMRegister src = g.ToDoubleRegister(source);
1164     if (destination->IsDoubleRegister()) {
1165       XMMRegister dst = g.ToDoubleRegister(destination);
1166       __ movsd(dst, src);
1167     } else {
1168       DCHECK(destination->IsDoubleStackSlot());
1169       Operand dst = g.ToOperand(destination);
1170       __ movsd(dst, src);
1171     }
1172   } else if (source->IsDoubleStackSlot()) {
1173     DCHECK(destination->IsDoubleRegister() || destination->IsDoubleStackSlot());
1174     Operand src = g.ToOperand(source);
1175     if (destination->IsDoubleRegister()) {
1176       XMMRegister dst = g.ToDoubleRegister(destination);
1177       __ movsd(dst, src);
1178     } else {
1179       // We rely on having xmm0 available as a fixed scratch register.
1180       Operand dst = g.ToOperand(destination);
1181       __ movsd(xmm0, src);
1182       __ movsd(dst, xmm0);
1183     }
1184   } else {
1185     UNREACHABLE();
1186   }
1187 }
1188
1189
1190 void CodeGenerator::AssembleSwap(InstructionOperand* source,
1191                                  InstructionOperand* destination) {
1192   X64OperandConverter g(this, NULL);
1193   // Dispatch on the source and destination operand kinds.  Not all
1194   // combinations are possible.
1195   if (source->IsRegister() && destination->IsRegister()) {
1196     // Register-register.
1197     __ xchgq(g.ToRegister(source), g.ToRegister(destination));
1198   } else if (source->IsRegister() && destination->IsStackSlot()) {
1199     Register src = g.ToRegister(source);
1200     Operand dst = g.ToOperand(destination);
1201     __ xchgq(src, dst);
1202   } else if ((source->IsStackSlot() && destination->IsStackSlot()) ||
1203              (source->IsDoubleStackSlot() &&
1204               destination->IsDoubleStackSlot())) {
1205     // Memory-memory.
1206     Register tmp = kScratchRegister;
1207     Operand src = g.ToOperand(source);
1208     Operand dst = g.ToOperand(destination);
1209     __ movq(tmp, dst);
1210     __ xchgq(tmp, src);
1211     __ movq(dst, tmp);
1212   } else if (source->IsDoubleRegister() && destination->IsDoubleRegister()) {
1213     // XMM register-register swap. We rely on having xmm0
1214     // available as a fixed scratch register.
1215     XMMRegister src = g.ToDoubleRegister(source);
1216     XMMRegister dst = g.ToDoubleRegister(destination);
1217     __ movsd(xmm0, src);
1218     __ movsd(src, dst);
1219     __ movsd(dst, xmm0);
1220   } else if (source->IsDoubleRegister() && destination->IsDoubleStackSlot()) {
1221     // XMM register-memory swap.  We rely on having xmm0
1222     // available as a fixed scratch register.
1223     XMMRegister src = g.ToDoubleRegister(source);
1224     Operand dst = g.ToOperand(destination);
1225     __ movsd(xmm0, src);
1226     __ movsd(src, dst);
1227     __ movsd(dst, xmm0);
1228   } else {
1229     // No other combinations are possible.
1230     UNREACHABLE();
1231   }
1232 }
1233
1234
1235 void CodeGenerator::AddNopForSmiCodeInlining() { __ nop(); }
1236
1237
1238 void CodeGenerator::EnsureSpaceForLazyDeopt() {
1239   int space_needed = Deoptimizer::patch_size();
1240   if (!info()->IsStub()) {
1241     // Ensure that we have enough space after the previous lazy-bailout
1242     // instruction for patching the code here.
1243     int current_pc = masm()->pc_offset();
1244     if (current_pc < last_lazy_deopt_pc_ + space_needed) {
1245       int padding_size = last_lazy_deopt_pc_ + space_needed - current_pc;
1246       __ Nop(padding_size);
1247     }
1248   }
1249   MarkLazyDeoptSite();
1250 }
1251
1252
1253 void CodeGenerator::EnsureRelocSpaceForLazyDeopt(Handle<Code> code) {}
1254
1255 #undef __
1256
1257 }  // namespace internal
1258 }  // namespace compiler
1259 }  // namespace v8