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       case kMode_M2:
  98       case kMode_M4:
  99       case kMode_M8: {
 100         Register index = InputRegister(NextOffset(offset));
 101         ScaleFactor scale = ScaleFor(kMode_M1, mode);
 102         int32_t disp = 0;
 103         return Operand(index, scale, disp);
 104       }
 105       case kMode_M1I:
 106       case kMode_M2I:
 107       case kMode_M4I:
 108       case kMode_M8I: {
 109         Register index = InputRegister(NextOffset(offset));
 110         ScaleFactor scale = ScaleFor(kMode_M1I, mode);
 111         int32_t disp = InputInt32(NextOffset(offset));
 112         return Operand(index, scale, disp);
 113       }
 114       case kMode_None:
 115         UNREACHABLE();
 116         return Operand(no_reg, 0);
 117     }
 118     UNREACHABLE();
 119     return Operand(no_reg, 0);
 120   }
 121
 122   Operand MemoryOperand() {
 123     int first_input = 0;
 124     return MemoryOperand(&first_input);
 125   }
 126 };
 127
 128
 129 static bool HasImmediateInput(Instruction* instr, int index) {
 130   return instr->InputAt(index)->IsImmediate();
 131 }
 132
 133
 134 #define ASSEMBLE_UNOP(asm_instr)         \
 135   do {                                   \
 136     if (instr->Output()->IsRegister()) { \
 137       __ asm_instr(i.OutputRegister());  \
 138     } else {                             \
 139       __ asm_instr(i.OutputOperand());   \
 140     }                                    \
 141   } while (0)
 142
 143
 144 #define ASSEMBLE_BINOP(asm_instr)                              \
 145   do {                                                         \
 146     if (HasImmediateInput(instr, 1)) {                         \
 147       if (instr->InputAt(0)->IsRegister()) {                   \
 148         __ asm_instr(i.InputRegister(0), i.InputImmediate(1)); \
 149       } else {                                                 \
 150         __ asm_instr(i.InputOperand(0), i.InputImmediate(1));  \
 151       }                                                        \
 152     } else {                                                   \
 153       if (instr->InputAt(1)->IsRegister()) {                   \
 154         __ asm_instr(i.InputRegister(0), i.InputRegister(1));  \
 155       } else {                                                 \
 156         __ asm_instr(i.InputRegister(0), i.InputOperand(1));   \
 157       }                                                        \
 158     }                                                          \
 159   } while (0)
 160
 161
 162 #define ASSEMBLE_MULT(asm_instr)                              \
 163   do {                                                        \
 164     if (HasImmediateInput(instr, 1)) {                        \
 165       if (instr->InputAt(0)->IsRegister()) {                  \
 166         __ asm_instr(i.OutputRegister(), i.InputRegister(0),  \
 167                      i.InputImmediate(1));                    \
 168       } else {                                                \
 169         __ asm_instr(i.OutputRegister(), i.InputOperand(0),   \
 170                      i.InputImmediate(1));                    \
 171       }                                                       \
 172     } else {                                                  \
 173       if (instr->InputAt(1)->IsRegister()) {                  \
 174         __ asm_instr(i.OutputRegister(), i.InputRegister(1)); \
 175       } else {                                                \
 176         __ asm_instr(i.OutputRegister(), i.InputOperand(1));  \
 177       }                                                       \
 178     }                                                         \
 179   } while (0)
 180
 181
 182 #define ASSEMBLE_SHIFT(asm_instr, width)                                   \
 183   do {                                                                     \
 184     if (HasImmediateInput(instr, 1)) {                                     \
 185       if (instr->Output()->IsRegister()) {                                 \
 186         __ asm_instr(i.OutputRegister(), Immediate(i.InputInt##width(1))); \
 187       } else {                                                             \
 188         __ asm_instr(i.OutputOperand(), Immediate(i.InputInt##width(1)));  \
 189       }                                                                    \
 190     } else {                                                               \
 191       if (instr->Output()->IsRegister()) {                                 \
 192         __ asm_instr##_cl(i.OutputRegister());                             \
 193       } else {                                                             \
 194         __ asm_instr##_cl(i.OutputOperand());                              \
 195       }                                                                    \
 196     }                                                                      \
 197   } while (0)
 198
 199
 200 #define ASSEMBLE_DOUBLE_BINOP(asm_instr)                                \
 201   do {                                                                  \
 202     if (instr->InputAt(1)->IsDoubleRegister()) {                        \
 203       __ asm_instr(i.InputDoubleRegister(0), i.InputDoubleRegister(1)); \
 204     } else {                                                            \
 205       __ asm_instr(i.InputDoubleRegister(0), i.InputOperand(1));        \
 206     }                                                                   \
 207   } while (0)
 208
 209
 210 // Assembles an instruction after register allocation, producing machine code.
 211 void CodeGenerator::AssembleArchInstruction(Instruction* instr) {
 212   X64OperandConverter i(this, instr);
 213
 214   switch (ArchOpcodeField::decode(instr->opcode())) {
 215     case kArchCallCodeObject: {
 216       EnsureSpaceForLazyDeopt();
 217       if (HasImmediateInput(instr, 0)) {
 218         Handle<Code> code = Handle<Code>::cast(i.InputHeapObject(0));
 219         __ Call(code, RelocInfo::CODE_TARGET);
 220       } else {
 221         Register reg = i.InputRegister(0);
 222         int entry = Code::kHeaderSize - kHeapObjectTag;
 223         __ Call(Operand(reg, entry));
 224       }
 225       AddSafepointAndDeopt(instr);
 226       break;
 227     }
 228     case kArchCallJSFunction: {
 229       EnsureSpaceForLazyDeopt();
 230       Register func = i.InputRegister(0);
 231       if (FLAG_debug_code) {
 232         // Check the function's context matches the context argument.
 233         __ cmpp(rsi, FieldOperand(func, JSFunction::kContextOffset));
 234         __ Assert(equal, kWrongFunctionContext);
 235       }
 236       __ Call(FieldOperand(func, JSFunction::kCodeEntryOffset));
 237       AddSafepointAndDeopt(instr);
 238       break;
 239     }
 240     case kArchJmp:
 241       __ jmp(GetLabel(i.InputRpo(0)));
 242       break;
 243     case kArchNop:
 244       // don't emit code for nops.
 245       break;
 246     case kArchRet:
 247       AssembleReturn();
 248       break;
 249     case kArchStackPointer:
 250       __ movq(i.OutputRegister(), rsp);
 251       break;
 252     case kArchTruncateDoubleToI:
 253       __ TruncateDoubleToI(i.OutputRegister(), i.InputDoubleRegister(0));
 254       break;
 255     case kX64Add32:
 256       ASSEMBLE_BINOP(addl);
 257       break;
 258     case kX64Add:
 259       ASSEMBLE_BINOP(addq);
 260       break;
 261     case kX64Sub32:
 262       ASSEMBLE_BINOP(subl);
 263       break;
 264     case kX64Sub:
 265       ASSEMBLE_BINOP(subq);
 266       break;
 267     case kX64And32:
 268       ASSEMBLE_BINOP(andl);
 269       break;
 270     case kX64And:
 271       ASSEMBLE_BINOP(andq);
 272       break;
 273     case kX64Cmp32:
 274       ASSEMBLE_BINOP(cmpl);
 275       break;
 276     case kX64Cmp:
 277       ASSEMBLE_BINOP(cmpq);
 278       break;
 279     case kX64Test32:
 280       ASSEMBLE_BINOP(testl);
 281       break;
 282     case kX64Test:
 283       ASSEMBLE_BINOP(testq);
 284       break;
 285     case kX64Imul32:
 286       ASSEMBLE_MULT(imull);
 287       break;
 288     case kX64Imul:
 289       ASSEMBLE_MULT(imulq);
 290       break;
 291     case kX64ImulHigh32:
 292       if (instr->InputAt(1)->IsRegister()) {
 293         __ imull(i.InputRegister(1));
 294       } else {
 295         __ imull(i.InputOperand(1));
 296       }
 297       break;
 298     case kX64UmulHigh32:
 299       if (instr->InputAt(1)->IsRegister()) {
 300         __ mull(i.InputRegister(1));
 301       } else {
 302         __ mull(i.InputOperand(1));
 303       }
 304       break;
 305     case kX64Idiv32:
 306       __ cdq();
 307       __ idivl(i.InputRegister(1));
 308       break;
 309     case kX64Idiv:
 310       __ cqo();
 311       __ idivq(i.InputRegister(1));
 312       break;
 313     case kX64Udiv32:
 314       __ xorl(rdx, rdx);
 315       __ divl(i.InputRegister(1));
 316       break;
 317     case kX64Udiv:
 318       __ xorq(rdx, rdx);
 319       __ divq(i.InputRegister(1));
 320       break;
 321     case kX64Not:
 322       ASSEMBLE_UNOP(notq);
 323       break;
 324     case kX64Not32:
 325       ASSEMBLE_UNOP(notl);
 326       break;
 327     case kX64Neg:
 328       ASSEMBLE_UNOP(negq);
 329       break;
 330     case kX64Neg32:
 331       ASSEMBLE_UNOP(negl);
 332       break;
 333     case kX64Or32:
 334       ASSEMBLE_BINOP(orl);
 335       break;
 336     case kX64Or:
 337       ASSEMBLE_BINOP(orq);
 338       break;
 339     case kX64Xor32:
 340       ASSEMBLE_BINOP(xorl);
 341       break;
 342     case kX64Xor:
 343       ASSEMBLE_BINOP(xorq);
 344       break;
 345     case kX64Shl32:
 346       ASSEMBLE_SHIFT(shll, 5);
 347       break;
 348     case kX64Shl:
 349       ASSEMBLE_SHIFT(shlq, 6);
 350       break;
 351     case kX64Shr32:
 352       ASSEMBLE_SHIFT(shrl, 5);
 353       break;
 354     case kX64Shr:
 355       ASSEMBLE_SHIFT(shrq, 6);
 356       break;
 357     case kX64Sar32:
 358       ASSEMBLE_SHIFT(sarl, 5);
 359       break;
 360     case kX64Sar:
 361       ASSEMBLE_SHIFT(sarq, 6);
 362       break;
 363     case kX64Ror32:
 364       ASSEMBLE_SHIFT(rorl, 5);
 365       break;
 366     case kX64Ror:
 367       ASSEMBLE_SHIFT(rorq, 6);
 368       break;
 369     case kSSEFloat64Cmp:
 370       ASSEMBLE_DOUBLE_BINOP(ucomisd);
 371       break;
 372     case kSSEFloat64Add:
 373       ASSEMBLE_DOUBLE_BINOP(addsd);
 374       break;
 375     case kSSEFloat64Sub:
 376       ASSEMBLE_DOUBLE_BINOP(subsd);
 377       break;
 378     case kSSEFloat64Mul:
 379       ASSEMBLE_DOUBLE_BINOP(mulsd);
 380       break;
 381     case kSSEFloat64Div:
 382       ASSEMBLE_DOUBLE_BINOP(divsd);
 383       break;
 384     case kSSEFloat64Mod: {
 385       __ subq(rsp, Immediate(kDoubleSize));
 386       // Move values to st(0) and st(1).
 387       __ movsd(Operand(rsp, 0), i.InputDoubleRegister(1));
 388       __ fld_d(Operand(rsp, 0));
 389       __ movsd(Operand(rsp, 0), i.InputDoubleRegister(0));
 390       __ fld_d(Operand(rsp, 0));
 391       // Loop while fprem isn't done.
 392       Label mod_loop;
 393       __ bind(&mod_loop);
 394       // This instructions traps on all kinds inputs, but we are assuming the
 395       // floating point control word is set to ignore them all.
 396       __ fprem();
 397       // The following 2 instruction implicitly use rax.
 398       __ fnstsw_ax();
 399       if (CpuFeatures::IsSupported(SAHF) && masm()->IsEnabled(SAHF)) {
 400         __ sahf();
 401       } else {
 402         __ shrl(rax, Immediate(8));
 403         __ andl(rax, Immediate(0xFF));
 404         __ pushq(rax);
 405         __ popfq();
 406       }
 407       __ j(parity_even, &mod_loop);
 408       // Move output to stack and clean up.
 409       __ fstp(1);
 410       __ fstp_d(Operand(rsp, 0));
 411       __ movsd(i.OutputDoubleRegister(), Operand(rsp, 0));
 412       __ addq(rsp, Immediate(kDoubleSize));
 413       break;
 414     }
 415     case kSSEFloat64Sqrt:
 416       if (instr->InputAt(0)->IsDoubleRegister()) {
 417         __ sqrtsd(i.OutputDoubleRegister(), i.InputDoubleRegister(0));
 418       } else {
 419         __ sqrtsd(i.OutputDoubleRegister(), i.InputOperand(0));
 420       }
 421       break;
 422     case kSSEFloat64Floor: {
 423       CpuFeatureScope sse_scope(masm(), SSE4_1);
 424       __ roundsd(i.OutputDoubleRegister(), i.InputDoubleRegister(0),
 425                  v8::internal::Assembler::kRoundDown);
 426       break;
 427     }
 428     case kSSEFloat64Ceil: {
 429       CpuFeatureScope sse_scope(masm(), SSE4_1);
 430       __ roundsd(i.OutputDoubleRegister(), i.InputDoubleRegister(0),
 431                  v8::internal::Assembler::kRoundUp);
 432       break;
 433     }
 434     case kSSEFloat64RoundTruncate: {
 435       CpuFeatureScope sse_scope(masm(), SSE4_1);
 436       __ roundsd(i.OutputDoubleRegister(), i.InputDoubleRegister(0),
 437                  v8::internal::Assembler::kRoundToZero);
 438       break;
 439     }
 440     case kSSECvtss2sd:
 441       if (instr->InputAt(0)->IsDoubleRegister()) {
 442         __ cvtss2sd(i.OutputDoubleRegister(), i.InputDoubleRegister(0));
 443       } else {
 444         __ cvtss2sd(i.OutputDoubleRegister(), i.InputOperand(0));
 445       }
 446       break;
 447     case kSSECvtsd2ss:
 448       if (instr->InputAt(0)->IsDoubleRegister()) {
 449         __ cvtsd2ss(i.OutputDoubleRegister(), i.InputDoubleRegister(0));
 450       } else {
 451         __ cvtsd2ss(i.OutputDoubleRegister(), i.InputOperand(0));
 452       }
 453       break;
 454     case kSSEFloat64ToInt32:
 455       if (instr->InputAt(0)->IsDoubleRegister()) {
 456         __ cvttsd2si(i.OutputRegister(), i.InputDoubleRegister(0));
 457       } else {
 458         __ cvttsd2si(i.OutputRegister(), i.InputOperand(0));
 459       }
 460       break;
 461     case kSSEFloat64ToUint32: {
 462       if (instr->InputAt(0)->IsDoubleRegister()) {
 463         __ cvttsd2siq(i.OutputRegister(), i.InputDoubleRegister(0));
 464       } else {
 465         __ cvttsd2siq(i.OutputRegister(), i.InputOperand(0));
 466       }
 467       __ AssertZeroExtended(i.OutputRegister());
 468       break;
 469     }
 470     case kSSEInt32ToFloat64:
 471       if (instr->InputAt(0)->IsRegister()) {
 472         __ cvtlsi2sd(i.OutputDoubleRegister(), i.InputRegister(0));
 473       } else {
 474         __ cvtlsi2sd(i.OutputDoubleRegister(), i.InputOperand(0));
 475       }
 476       break;
 477     case kSSEUint32ToFloat64:
 478       if (instr->InputAt(0)->IsRegister()) {
 479         __ movl(kScratchRegister, i.InputRegister(0));
 480       } else {
 481         __ movl(kScratchRegister, i.InputOperand(0));
 482       }
 483       __ cvtqsi2sd(i.OutputDoubleRegister(), kScratchRegister);
 484       break;
 485     case kX64Movsxbl:
 486       if (instr->addressing_mode() != kMode_None) {
 487         __ movsxbl(i.OutputRegister(), i.MemoryOperand());
 488       } else if (instr->InputAt(0)->IsRegister()) {
 489         __ movsxbl(i.OutputRegister(), i.InputRegister(0));
 490       } else {
 491         __ movsxbl(i.OutputRegister(), i.InputOperand(0));
 492       }
 493       __ AssertZeroExtended(i.OutputRegister());
 494       break;
 495     case kX64Movzxbl:
 496       __ movzxbl(i.OutputRegister(), i.MemoryOperand());
 497       break;
 498     case kX64Movb: {
 499       int index = 0;
 500       Operand operand = i.MemoryOperand(&index);
 501       if (HasImmediateInput(instr, index)) {
 502         __ movb(operand, Immediate(i.InputInt8(index)));
 503       } else {
 504         __ movb(operand, i.InputRegister(index));
 505       }
 506       break;
 507     }
 508     case kX64Movsxwl:
 509       if (instr->addressing_mode() != kMode_None) {
 510         __ movsxwl(i.OutputRegister(), i.MemoryOperand());
 511       } else if (instr->InputAt(0)->IsRegister()) {
 512         __ movsxwl(i.OutputRegister(), i.InputRegister(0));
 513       } else {
 514         __ movsxwl(i.OutputRegister(), i.InputOperand(0));
 515       }
 516       __ AssertZeroExtended(i.OutputRegister());
 517       break;
 518     case kX64Movzxwl:
 519       __ movzxwl(i.OutputRegister(), i.MemoryOperand());
 520       __ AssertZeroExtended(i.OutputRegister());
 521       break;
 522     case kX64Movw: {
 523       int index = 0;
 524       Operand operand = i.MemoryOperand(&index);
 525       if (HasImmediateInput(instr, index)) {
 526         __ movw(operand, Immediate(i.InputInt16(index)));
 527       } else {
 528         __ movw(operand, i.InputRegister(index));
 529       }
 530       break;
 531     }
 532     case kX64Movl:
 533       if (instr->HasOutput()) {
 534         if (instr->addressing_mode() == kMode_None) {
 535           if (instr->InputAt(0)->IsRegister()) {
 536             __ movl(i.OutputRegister(), i.InputRegister(0));
 537           } else {
 538             __ movl(i.OutputRegister(), i.InputOperand(0));
 539           }
 540         } else {
 541           __ movl(i.OutputRegister(), i.MemoryOperand());
 542         }
 543         __ AssertZeroExtended(i.OutputRegister());
 544       } else {
 545         int index = 0;
 546         Operand operand = i.MemoryOperand(&index);
 547         if (HasImmediateInput(instr, index)) {
 548           __ movl(operand, i.InputImmediate(index));
 549         } else {
 550           __ movl(operand, i.InputRegister(index));
 551         }
 552       }
 553       break;
 554     case kX64Movsxlq: {
 555       if (instr->InputAt(0)->IsRegister()) {
 556         __ movsxlq(i.OutputRegister(), i.InputRegister(0));
 557       } else {
 558         __ movsxlq(i.OutputRegister(), i.InputOperand(0));
 559       }
 560       break;
 561     }
 562     case kX64Movq:
 563       if (instr->HasOutput()) {
 564         __ movq(i.OutputRegister(), i.MemoryOperand());
 565       } else {
 566         int index = 0;
 567         Operand operand = i.MemoryOperand(&index);
 568         if (HasImmediateInput(instr, index)) {
 569           __ movq(operand, i.InputImmediate(index));
 570         } else {
 571           __ movq(operand, i.InputRegister(index));
 572         }
 573       }
 574       break;
 575     case kX64Movss:
 576       if (instr->HasOutput()) {
 577         __ movss(i.OutputDoubleRegister(), i.MemoryOperand());
 578       } else {
 579         int index = 0;
 580         Operand operand = i.MemoryOperand(&index);
 581         __ movss(operand, i.InputDoubleRegister(index));
 582       }
 583       break;
 584     case kX64Movsd:
 585       if (instr->HasOutput()) {
 586         __ movsd(i.OutputDoubleRegister(), i.MemoryOperand());
 587       } else {
 588         int index = 0;
 589         Operand operand = i.MemoryOperand(&index);
 590         __ movsd(operand, i.InputDoubleRegister(index));
 591       }
 592       break;
 593     case kX64Lea32:
 594       __ leal(i.OutputRegister(), i.MemoryOperand());
 595       __ AssertZeroExtended(i.OutputRegister());
 596       break;
 597     case kX64Lea:
 598       __ leaq(i.OutputRegister(), i.MemoryOperand());
 599       break;
 600     case kX64Dec32:
 601       __ decl(i.OutputRegister());
 602       break;
 603     case kX64Inc32:
 604       __ incl(i.OutputRegister());
 605       break;
 606     case kX64Push:
 607       if (HasImmediateInput(instr, 0)) {
 608         __ pushq(i.InputImmediate(0));
 609       } else {
 610         if (instr->InputAt(0)->IsRegister()) {
 611           __ pushq(i.InputRegister(0));
 612         } else {
 613           __ pushq(i.InputOperand(0));
 614         }
 615       }
 616       break;
 617     case kX64StoreWriteBarrier: {
 618       Register object = i.InputRegister(0);
 619       Register index = i.InputRegister(1);
 620       Register value = i.InputRegister(2);
 621       __ movsxlq(index, index);
 622       __ movq(Operand(object, index, times_1, 0), value);
 623       __ leaq(index, Operand(object, index, times_1, 0));
 624       SaveFPRegsMode mode =
 625           frame()->DidAllocateDoubleRegisters() ? kSaveFPRegs : kDontSaveFPRegs;
 626       __ RecordWrite(object, index, value, mode);
 627       break;
 628     }
 629   }
 630 }
 631
 632
 633 // Assembles branches after this instruction.
 634 void CodeGenerator::AssembleArchBranch(Instruction* instr,
 635                                        FlagsCondition condition) {
 636   X64OperandConverter i(this, instr);
 637   Label done;
 638
 639   // Emit a branch. The true and false targets are always the last two inputs
 640   // to the instruction.
 641   BasicBlock::RpoNumber tblock =
 642       i.InputRpo(static_cast<int>(instr->InputCount()) - 2);
 643   BasicBlock::RpoNumber fblock =
 644       i.InputRpo(static_cast<int>(instr->InputCount()) - 1);
 645   bool fallthru = IsNextInAssemblyOrder(fblock);
 646   Label* tlabel = GetLabel(tblock);
 647   Label* flabel = fallthru ? &done : GetLabel(fblock);
 648   Label::Distance flabel_distance = fallthru ? Label::kNear : Label::kFar;
 649   switch (condition) {
 650     case kUnorderedEqual:
 651       __ j(parity_even, flabel, flabel_distance);
 652     // Fall through.
 653     case kEqual:
 654       __ j(equal, tlabel);
 655       break;
 656     case kUnorderedNotEqual:
 657       __ j(parity_even, tlabel);
 658     // Fall through.
 659     case kNotEqual:
 660       __ j(not_equal, tlabel);
 661       break;
 662     case kSignedLessThan:
 663       __ j(less, tlabel);
 664       break;
 665     case kSignedGreaterThanOrEqual:
 666       __ j(greater_equal, tlabel);
 667       break;
 668     case kSignedLessThanOrEqual:
 669       __ j(less_equal, tlabel);
 670       break;
 671     case kSignedGreaterThan:
 672       __ j(greater, tlabel);
 673       break;
 674     case kUnorderedLessThan:
 675       __ j(parity_even, flabel, flabel_distance);
 676     // Fall through.
 677     case kUnsignedLessThan:
 678       __ j(below, tlabel);
 679       break;
 680     case kUnorderedGreaterThanOrEqual:
 681       __ j(parity_even, tlabel);
 682     // Fall through.
 683     case kUnsignedGreaterThanOrEqual:
 684       __ j(above_equal, tlabel);
 685       break;
 686     case kUnorderedLessThanOrEqual:
 687       __ j(parity_even, flabel, flabel_distance);
 688     // Fall through.
 689     case kUnsignedLessThanOrEqual:
 690       __ j(below_equal, tlabel);
 691       break;
 692     case kUnorderedGreaterThan:
 693       __ j(parity_even, tlabel);
 694     // Fall through.
 695     case kUnsignedGreaterThan:
 696       __ j(above, tlabel);
 697       break;
 698     case kOverflow:
 699       __ j(overflow, tlabel);
 700       break;
 701     case kNotOverflow:
 702       __ j(no_overflow, tlabel);
 703       break;
 704   }
 705   if (!fallthru) __ jmp(flabel, flabel_distance);  // no fallthru to flabel.
 706   __ bind(&done);
 707 }
 708
 709
 710 // Assembles boolean materializations after this instruction.
 711 void CodeGenerator::AssembleArchBoolean(Instruction* instr,
 712                                         FlagsCondition condition) {
 713   X64OperandConverter i(this, instr);
 714   Label done;
 715
 716   // Materialize a full 64-bit 1 or 0 value. The result register is always the
 717   // last output of the instruction.
 718   Label check;
 719   DCHECK_NE(0, static_cast<int>(instr->OutputCount()));
 720   Register reg = i.OutputRegister(static_cast<int>(instr->OutputCount() - 1));
 721   Condition cc = no_condition;
 722   switch (condition) {
 723     case kUnorderedEqual:
 724       __ j(parity_odd, &check, Label::kNear);
 725       __ movl(reg, Immediate(0));
 726       __ jmp(&done, Label::kNear);
 727     // Fall through.
 728     case kEqual:
 729       cc = equal;
 730       break;
 731     case kUnorderedNotEqual:
 732       __ j(parity_odd, &check, Label::kNear);
 733       __ movl(reg, Immediate(1));
 734       __ jmp(&done, Label::kNear);
 735     // Fall through.
 736     case kNotEqual:
 737       cc = not_equal;
 738       break;
 739     case kSignedLessThan:
 740       cc = less;
 741       break;
 742     case kSignedGreaterThanOrEqual:
 743       cc = greater_equal;
 744       break;
 745     case kSignedLessThanOrEqual:
 746       cc = less_equal;
 747       break;
 748     case kSignedGreaterThan:
 749       cc = greater;
 750       break;
 751     case kUnorderedLessThan:
 752       __ j(parity_odd, &check, Label::kNear);
 753       __ movl(reg, Immediate(0));
 754       __ jmp(&done, Label::kNear);
 755     // Fall through.
 756     case kUnsignedLessThan:
 757       cc = below;
 758       break;
 759     case kUnorderedGreaterThanOrEqual:
 760       __ j(parity_odd, &check, Label::kNear);
 761       __ movl(reg, Immediate(1));
 762       __ jmp(&done, Label::kNear);
 763     // Fall through.
 764     case kUnsignedGreaterThanOrEqual:
 765       cc = above_equal;
 766       break;
 767     case kUnorderedLessThanOrEqual:
 768       __ j(parity_odd, &check, Label::kNear);
 769       __ movl(reg, Immediate(0));
 770       __ jmp(&done, Label::kNear);
 771     // Fall through.
 772     case kUnsignedLessThanOrEqual:
 773       cc = below_equal;
 774       break;
 775     case kUnorderedGreaterThan:
 776       __ j(parity_odd, &check, Label::kNear);
 777       __ movl(reg, Immediate(1));
 778       __ jmp(&done, Label::kNear);
 779     // Fall through.
 780     case kUnsignedGreaterThan:
 781       cc = above;
 782       break;
 783     case kOverflow:
 784       cc = overflow;
 785       break;
 786     case kNotOverflow:
 787       cc = no_overflow;
 788       break;
 789   }
 790   __ bind(&check);
 791   __ setcc(cc, reg);
 792   __ movzxbl(reg, reg);
 793   __ bind(&done);
 794 }
 795
 796
 797 void CodeGenerator::AssembleDeoptimizerCall(int deoptimization_id) {
 798   Address deopt_entry = Deoptimizer::GetDeoptimizationEntry(
 799       isolate(), deoptimization_id, Deoptimizer::LAZY);
 800   __ call(deopt_entry, RelocInfo::RUNTIME_ENTRY);
 801 }
 802
 803
 804 void CodeGenerator::AssemblePrologue() {
 805   CallDescriptor* descriptor = linkage()->GetIncomingDescriptor();
 806   int stack_slots = frame()->GetSpillSlotCount();
 807   if (descriptor->kind() == CallDescriptor::kCallAddress) {
 808     __ pushq(rbp);
 809     __ movq(rbp, rsp);
 810     const RegList saves = descriptor->CalleeSavedRegisters();
 811     if (saves != 0) {  // Save callee-saved registers.
 812       int register_save_area_size = 0;
 813       for (int i = Register::kNumRegisters - 1; i >= 0; i--) {
 814         if (!((1 << i) & saves)) continue;
 815         __ pushq(Register::from_code(i));
 816         register_save_area_size += kPointerSize;
 817       }
 818       frame()->SetRegisterSaveAreaSize(register_save_area_size);
 819     }
 820   } else if (descriptor->IsJSFunctionCall()) {
 821     CompilationInfo* info = this->info();
 822     __ Prologue(info->IsCodePreAgingActive());
 823     frame()->SetRegisterSaveAreaSize(
 824         StandardFrameConstants::kFixedFrameSizeFromFp);
 825   } else {
 826     __ StubPrologue();
 827     frame()->SetRegisterSaveAreaSize(
 828         StandardFrameConstants::kFixedFrameSizeFromFp);
 829   }
 830   if (stack_slots > 0) {
 831     __ subq(rsp, Immediate(stack_slots * kPointerSize));
 832   }
 833 }
 834
 835
 836 void CodeGenerator::AssembleReturn() {
 837   CallDescriptor* descriptor = linkage()->GetIncomingDescriptor();
 838   if (descriptor->kind() == CallDescriptor::kCallAddress) {
 839     if (frame()->GetRegisterSaveAreaSize() > 0) {
 840       // Remove this frame's spill slots first.
 841       int stack_slots = frame()->GetSpillSlotCount();
 842       if (stack_slots > 0) {
 843         __ addq(rsp, Immediate(stack_slots * kPointerSize));
 844       }
 845       const RegList saves = descriptor->CalleeSavedRegisters();
 846       // Restore registers.
 847       if (saves != 0) {
 848         for (int i = 0; i < Register::kNumRegisters; i++) {
 849           if (!((1 << i) & saves)) continue;
 850           __ popq(Register::from_code(i));
 851         }
 852       }
 853       __ popq(rbp);  // Pop caller's frame pointer.
 854       __ ret(0);
 855     } else {
 856       // No saved registers.
 857       __ movq(rsp, rbp);  // Move stack pointer back to frame pointer.
 858       __ popq(rbp);       // Pop caller's frame pointer.
 859       __ ret(0);
 860     }
 861   } else {
 862     __ movq(rsp, rbp);  // Move stack pointer back to frame pointer.
 863     __ popq(rbp);       // Pop caller's frame pointer.
 864     int pop_count = descriptor->IsJSFunctionCall()
 865                         ? static_cast<int>(descriptor->JSParameterCount())
 866                         : 0;
 867     __ ret(pop_count * kPointerSize);
 868   }
 869 }
 870
 871
 872 void CodeGenerator::AssembleMove(InstructionOperand* source,
 873                                  InstructionOperand* destination) {
 874   X64OperandConverter g(this, NULL);
 875   // Dispatch on the source and destination operand kinds.  Not all
 876   // combinations are possible.
 877   if (source->IsRegister()) {
 878     DCHECK(destination->IsRegister() || destination->IsStackSlot());
 879     Register src = g.ToRegister(source);
 880     if (destination->IsRegister()) {
 881       __ movq(g.ToRegister(destination), src);
 882     } else {
 883       __ movq(g.ToOperand(destination), src);
 884     }
 885   } else if (source->IsStackSlot()) {
 886     DCHECK(destination->IsRegister() || destination->IsStackSlot());
 887     Operand src = g.ToOperand(source);
 888     if (destination->IsRegister()) {
 889       Register dst = g.ToRegister(destination);
 890       __ movq(dst, src);
 891     } else {
 892       // Spill on demand to use a temporary register for memory-to-memory
 893       // moves.
 894       Register tmp = kScratchRegister;
 895       Operand dst = g.ToOperand(destination);
 896       __ movq(tmp, src);
 897       __ movq(dst, tmp);
 898     }
 899   } else if (source->IsConstant()) {
 900     ConstantOperand* constant_source = ConstantOperand::cast(source);
 901     Constant src = g.ToConstant(constant_source);
 902     if (destination->IsRegister() || destination->IsStackSlot()) {
 903       Register dst = destination->IsRegister() ? g.ToRegister(destination)
 904                                                : kScratchRegister;
 905       switch (src.type()) {
 906         case Constant::kInt32:
 907           // TODO(dcarney): don't need scratch in this case.
 908           __ Set(dst, src.ToInt32());
 909           break;
 910         case Constant::kInt64:
 911           __ Set(dst, src.ToInt64());
 912           break;
 913         case Constant::kFloat32:
 914           __ Move(dst,
 915                   isolate()->factory()->NewNumber(src.ToFloat32(), TENURED));
 916           break;
 917         case Constant::kFloat64:
 918           __ Move(dst,
 919                   isolate()->factory()->NewNumber(src.ToFloat64(), TENURED));
 920           break;
 921         case Constant::kExternalReference:
 922           __ Move(dst, src.ToExternalReference());
 923           break;
 924         case Constant::kHeapObject:
 925           __ Move(dst, src.ToHeapObject());
 926           break;
 927       }
 928       if (destination->IsStackSlot()) {
 929         __ movq(g.ToOperand(destination), kScratchRegister);
 930       }
 931     } else if (src.type() == Constant::kFloat32) {
 932       // TODO(turbofan): Can we do better here?
 933       uint32_t src_const = bit_cast<uint32_t>(src.ToFloat32());
 934       if (destination->IsDoubleRegister()) {
 935         __ Move(g.ToDoubleRegister(destination), src_const);
 936       } else {
 937         DCHECK(destination->IsDoubleStackSlot());
 938         Operand dst = g.ToOperand(destination);
 939         __ movl(dst, Immediate(src_const));
 940       }
 941     } else {
 942       DCHECK_EQ(Constant::kFloat64, src.type());
 943       uint64_t src_const = bit_cast<uint64_t>(src.ToFloat64());
 944       if (destination->IsDoubleRegister()) {
 945         __ Move(g.ToDoubleRegister(destination), src_const);
 946       } else {
 947         DCHECK(destination->IsDoubleStackSlot());
 948         __ movq(kScratchRegister, src_const);
 949         __ movq(g.ToOperand(destination), kScratchRegister);
 950       }
 951     }
 952   } else if (source->IsDoubleRegister()) {
 953     XMMRegister src = g.ToDoubleRegister(source);
 954     if (destination->IsDoubleRegister()) {
 955       XMMRegister dst = g.ToDoubleRegister(destination);
 956       __ movsd(dst, src);
 957     } else {
 958       DCHECK(destination->IsDoubleStackSlot());
 959       Operand dst = g.ToOperand(destination);
 960       __ movsd(dst, src);
 961     }
 962   } else if (source->IsDoubleStackSlot()) {
 963     DCHECK(destination->IsDoubleRegister() || destination->IsDoubleStackSlot());
 964     Operand src = g.ToOperand(source);
 965     if (destination->IsDoubleRegister()) {
 966       XMMRegister dst = g.ToDoubleRegister(destination);
 967       __ movsd(dst, src);
 968     } else {
 969       // We rely on having xmm0 available as a fixed scratch register.
 970       Operand dst = g.ToOperand(destination);
 971       __ movsd(xmm0, src);
 972       __ movsd(dst, xmm0);
 973     }
 974   } else {
 975     UNREACHABLE();
 976   }
 977 }
 978
 979
 980 void CodeGenerator::AssembleSwap(InstructionOperand* source,
 981                                  InstructionOperand* destination) {
 982   X64OperandConverter g(this, NULL);
 983   // Dispatch on the source and destination operand kinds.  Not all
 984   // combinations are possible.
 985   if (source->IsRegister() && destination->IsRegister()) {
 986     // Register-register.
 987     __ xchgq(g.ToRegister(source), g.ToRegister(destination));
 988   } else if (source->IsRegister() && destination->IsStackSlot()) {
 989     Register src = g.ToRegister(source);
 990     Operand dst = g.ToOperand(destination);
 991     __ xchgq(src, dst);
 992   } else if ((source->IsStackSlot() && destination->IsStackSlot()) ||
 993              (source->IsDoubleStackSlot() &&
 994               destination->IsDoubleStackSlot())) {
 995     // Memory-memory.
 996     Register tmp = kScratchRegister;
 997     Operand src = g.ToOperand(source);
 998     Operand dst = g.ToOperand(destination);
 999     __ movq(tmp, dst);
1000     __ xchgq(tmp, src);
1001     __ movq(dst, tmp);
1002   } else if (source->IsDoubleRegister() && destination->IsDoubleRegister()) {
1003     // XMM register-register swap. We rely on having xmm0
1004     // available as a fixed scratch register.
1005     XMMRegister src = g.ToDoubleRegister(source);
1006     XMMRegister dst = g.ToDoubleRegister(destination);
1007     __ movsd(xmm0, src);
1008     __ movsd(src, dst);
1009     __ movsd(dst, xmm0);
1010   } else if (source->IsDoubleRegister() && destination->IsDoubleStackSlot()) {
1011     // XMM register-memory swap.  We rely on having xmm0
1012     // available as a fixed scratch register.
1013     XMMRegister src = g.ToDoubleRegister(source);
1014     Operand dst = g.ToOperand(destination);
1015     __ movsd(xmm0, src);
1016     __ movsd(src, dst);
1017     __ movsd(dst, xmm0);
1018   } else {
1019     // No other combinations are possible.
1020     UNREACHABLE();
1021   }
1022 }
1023
1024
1025 void CodeGenerator::AddNopForSmiCodeInlining() { __ nop(); }
1026
1027
1028 void CodeGenerator::EnsureSpaceForLazyDeopt() {
1029   int space_needed = Deoptimizer::patch_size();
1030   if (!info()->IsStub()) {
1031     // Ensure that we have enough space after the previous lazy-bailout
1032     // instruction for patching the code here.
1033     int current_pc = masm()->pc_offset();
1034     if (current_pc < last_lazy_deopt_pc_ + space_needed) {
1035       int padding_size = last_lazy_deopt_pc_ + space_needed - current_pc;
1036       __ Nop(padding_size);
1037     }
1038   }
1039   MarkLazyDeoptSite();
1040 }
1041
1042 #undef __
1043
1044 }  // namespace internal
1045 }  // namespace compiler
1046 }  // namespace v8