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(code_->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       __ imull(i.InputRegister(1));
 293       break;
 294     case kX64Idiv32:
 295       __ cdq();
 296       __ idivl(i.InputRegister(1));
 297       break;
 298     case kX64Idiv:
 299       __ cqo();
 300       __ idivq(i.InputRegister(1));
 301       break;
 302     case kX64Udiv32:
 303       __ xorl(rdx, rdx);
 304       __ divl(i.InputRegister(1));
 305       break;
 306     case kX64Udiv:
 307       __ xorq(rdx, rdx);
 308       __ divq(i.InputRegister(1));
 309       break;
 310     case kX64Not:
 311       ASSEMBLE_UNOP(notq);
 312       break;
 313     case kX64Not32:
 314       ASSEMBLE_UNOP(notl);
 315       break;
 316     case kX64Neg:
 317       ASSEMBLE_UNOP(negq);
 318       break;
 319     case kX64Neg32:
 320       ASSEMBLE_UNOP(negl);
 321       break;
 322     case kX64Or32:
 323       ASSEMBLE_BINOP(orl);
 324       break;
 325     case kX64Or:
 326       ASSEMBLE_BINOP(orq);
 327       break;
 328     case kX64Xor32:
 329       ASSEMBLE_BINOP(xorl);
 330       break;
 331     case kX64Xor:
 332       ASSEMBLE_BINOP(xorq);
 333       break;
 334     case kX64Shl32:
 335       ASSEMBLE_SHIFT(shll, 5);
 336       break;
 337     case kX64Shl:
 338       ASSEMBLE_SHIFT(shlq, 6);
 339       break;
 340     case kX64Shr32:
 341       ASSEMBLE_SHIFT(shrl, 5);
 342       break;
 343     case kX64Shr:
 344       ASSEMBLE_SHIFT(shrq, 6);
 345       break;
 346     case kX64Sar32:
 347       ASSEMBLE_SHIFT(sarl, 5);
 348       break;
 349     case kX64Sar:
 350       ASSEMBLE_SHIFT(sarq, 6);
 351       break;
 352     case kX64Ror32:
 353       ASSEMBLE_SHIFT(rorl, 5);
 354       break;
 355     case kX64Ror:
 356       ASSEMBLE_SHIFT(rorq, 6);
 357       break;
 358     case kSSEFloat64Cmp:
 359       ASSEMBLE_DOUBLE_BINOP(ucomisd);
 360       break;
 361     case kSSEFloat64Add:
 362       ASSEMBLE_DOUBLE_BINOP(addsd);
 363       break;
 364     case kSSEFloat64Sub:
 365       ASSEMBLE_DOUBLE_BINOP(subsd);
 366       break;
 367     case kSSEFloat64Mul:
 368       ASSEMBLE_DOUBLE_BINOP(mulsd);
 369       break;
 370     case kSSEFloat64Div:
 371       ASSEMBLE_DOUBLE_BINOP(divsd);
 372       break;
 373     case kSSEFloat64Mod: {
 374       __ subq(rsp, Immediate(kDoubleSize));
 375       // Move values to st(0) and st(1).
 376       __ movsd(Operand(rsp, 0), i.InputDoubleRegister(1));
 377       __ fld_d(Operand(rsp, 0));
 378       __ movsd(Operand(rsp, 0), i.InputDoubleRegister(0));
 379       __ fld_d(Operand(rsp, 0));
 380       // Loop while fprem isn't done.
 381       Label mod_loop;
 382       __ bind(&mod_loop);
 383       // This instructions traps on all kinds inputs, but we are assuming the
 384       // floating point control word is set to ignore them all.
 385       __ fprem();
 386       // The following 2 instruction implicitly use rax.
 387       __ fnstsw_ax();
 388       if (CpuFeatures::IsSupported(SAHF) && masm()->IsEnabled(SAHF)) {
 389         __ sahf();
 390       } else {
 391         __ shrl(rax, Immediate(8));
 392         __ andl(rax, Immediate(0xFF));
 393         __ pushq(rax);
 394         __ popfq();
 395       }
 396       __ j(parity_even, &mod_loop);
 397       // Move output to stack and clean up.
 398       __ fstp(1);
 399       __ fstp_d(Operand(rsp, 0));
 400       __ movsd(i.OutputDoubleRegister(), Operand(rsp, 0));
 401       __ addq(rsp, Immediate(kDoubleSize));
 402       break;
 403     }
 404     case kSSEFloat64Sqrt:
 405       if (instr->InputAt(0)->IsDoubleRegister()) {
 406         __ sqrtsd(i.OutputDoubleRegister(), i.InputDoubleRegister(0));
 407       } else {
 408         __ sqrtsd(i.OutputDoubleRegister(), i.InputOperand(0));
 409       }
 410       break;
 411     case kSSEFloat64Floor: {
 412       CpuFeatureScope sse_scope(masm(), SSE4_1);
 413       __ roundsd(i.OutputDoubleRegister(), i.InputDoubleRegister(0),
 414                  v8::internal::Assembler::kRoundDown);
 415       break;
 416     }
 417     case kSSEFloat64Ceil: {
 418       CpuFeatureScope sse_scope(masm(), SSE4_1);
 419       __ roundsd(i.OutputDoubleRegister(), i.InputDoubleRegister(0),
 420                  v8::internal::Assembler::kRoundUp);
 421       break;
 422     }
 423     case kSSEFloat64RoundTruncate: {
 424       CpuFeatureScope sse_scope(masm(), SSE4_1);
 425       __ roundsd(i.OutputDoubleRegister(), i.InputDoubleRegister(0),
 426                  v8::internal::Assembler::kRoundToZero);
 427       break;
 428     }
 429     case kSSECvtss2sd:
 430       if (instr->InputAt(0)->IsDoubleRegister()) {
 431         __ cvtss2sd(i.OutputDoubleRegister(), i.InputDoubleRegister(0));
 432       } else {
 433         __ cvtss2sd(i.OutputDoubleRegister(), i.InputOperand(0));
 434       }
 435       break;
 436     case kSSECvtsd2ss:
 437       if (instr->InputAt(0)->IsDoubleRegister()) {
 438         __ cvtsd2ss(i.OutputDoubleRegister(), i.InputDoubleRegister(0));
 439       } else {
 440         __ cvtsd2ss(i.OutputDoubleRegister(), i.InputOperand(0));
 441       }
 442       break;
 443     case kSSEFloat64ToInt32:
 444       if (instr->InputAt(0)->IsDoubleRegister()) {
 445         __ cvttsd2si(i.OutputRegister(), i.InputDoubleRegister(0));
 446       } else {
 447         __ cvttsd2si(i.OutputRegister(), i.InputOperand(0));
 448       }
 449       break;
 450     case kSSEFloat64ToUint32: {
 451       if (instr->InputAt(0)->IsDoubleRegister()) {
 452         __ cvttsd2siq(i.OutputRegister(), i.InputDoubleRegister(0));
 453       } else {
 454         __ cvttsd2siq(i.OutputRegister(), i.InputOperand(0));
 455       }
 456       __ AssertZeroExtended(i.OutputRegister());
 457       break;
 458     }
 459     case kSSEInt32ToFloat64:
 460       if (instr->InputAt(0)->IsRegister()) {
 461         __ cvtlsi2sd(i.OutputDoubleRegister(), i.InputRegister(0));
 462       } else {
 463         __ cvtlsi2sd(i.OutputDoubleRegister(), i.InputOperand(0));
 464       }
 465       break;
 466     case kSSEUint32ToFloat64:
 467       if (instr->InputAt(0)->IsRegister()) {
 468         __ movl(kScratchRegister, i.InputRegister(0));
 469       } else {
 470         __ movl(kScratchRegister, i.InputOperand(0));
 471       }
 472       __ cvtqsi2sd(i.OutputDoubleRegister(), kScratchRegister);
 473       break;
 474     case kX64Movsxbl:
 475       __ movsxbl(i.OutputRegister(), i.MemoryOperand());
 476       break;
 477     case kX64Movzxbl:
 478       __ movzxbl(i.OutputRegister(), i.MemoryOperand());
 479       break;
 480     case kX64Movb: {
 481       int index = 0;
 482       Operand operand = i.MemoryOperand(&index);
 483       if (HasImmediateInput(instr, index)) {
 484         __ movb(operand, Immediate(i.InputInt8(index)));
 485       } else {
 486         __ movb(operand, i.InputRegister(index));
 487       }
 488       break;
 489     }
 490     case kX64Movsxwl:
 491       __ movsxwl(i.OutputRegister(), i.MemoryOperand());
 492       break;
 493     case kX64Movzxwl:
 494       __ movzxwl(i.OutputRegister(), i.MemoryOperand());
 495       break;
 496     case kX64Movw: {
 497       int index = 0;
 498       Operand operand = i.MemoryOperand(&index);
 499       if (HasImmediateInput(instr, index)) {
 500         __ movw(operand, Immediate(i.InputInt16(index)));
 501       } else {
 502         __ movw(operand, i.InputRegister(index));
 503       }
 504       break;
 505     }
 506     case kX64Movl:
 507       if (instr->HasOutput()) {
 508         if (instr->addressing_mode() == kMode_None) {
 509           if (instr->InputAt(0)->IsRegister()) {
 510             __ movl(i.OutputRegister(), i.InputRegister(0));
 511           } else {
 512             __ movl(i.OutputRegister(), i.InputOperand(0));
 513           }
 514         } else {
 515           __ movl(i.OutputRegister(), i.MemoryOperand());
 516         }
 517       } else {
 518         int index = 0;
 519         Operand operand = i.MemoryOperand(&index);
 520         if (HasImmediateInput(instr, index)) {
 521           __ movl(operand, i.InputImmediate(index));
 522         } else {
 523           __ movl(operand, i.InputRegister(index));
 524         }
 525       }
 526       break;
 527     case kX64Movsxlq: {
 528       if (instr->InputAt(0)->IsRegister()) {
 529         __ movsxlq(i.OutputRegister(), i.InputRegister(0));
 530       } else {
 531         __ movsxlq(i.OutputRegister(), i.InputOperand(0));
 532       }
 533       break;
 534     }
 535     case kX64Movq:
 536       if (instr->HasOutput()) {
 537         __ movq(i.OutputRegister(), i.MemoryOperand());
 538       } else {
 539         int index = 0;
 540         Operand operand = i.MemoryOperand(&index);
 541         if (HasImmediateInput(instr, index)) {
 542           __ movq(operand, i.InputImmediate(index));
 543         } else {
 544           __ movq(operand, i.InputRegister(index));
 545         }
 546       }
 547       break;
 548     case kX64Movss:
 549       if (instr->HasOutput()) {
 550         __ movss(i.OutputDoubleRegister(), i.MemoryOperand());
 551       } else {
 552         int index = 0;
 553         Operand operand = i.MemoryOperand(&index);
 554         __ movss(operand, i.InputDoubleRegister(index));
 555       }
 556       break;
 557     case kX64Movsd:
 558       if (instr->HasOutput()) {
 559         __ movsd(i.OutputDoubleRegister(), i.MemoryOperand());
 560       } else {
 561         int index = 0;
 562         Operand operand = i.MemoryOperand(&index);
 563         __ movsd(operand, i.InputDoubleRegister(index));
 564       }
 565       break;
 566     case kX64Lea32:
 567       __ leal(i.OutputRegister(), i.MemoryOperand());
 568       break;
 569     case kX64Lea:
 570       __ leaq(i.OutputRegister(), i.MemoryOperand());
 571       break;
 572     case kX64Push:
 573       if (HasImmediateInput(instr, 0)) {
 574         __ pushq(i.InputImmediate(0));
 575       } else {
 576         if (instr->InputAt(0)->IsRegister()) {
 577           __ pushq(i.InputRegister(0));
 578         } else {
 579           __ pushq(i.InputOperand(0));
 580         }
 581       }
 582       break;
 583     case kX64StoreWriteBarrier: {
 584       Register object = i.InputRegister(0);
 585       Register index = i.InputRegister(1);
 586       Register value = i.InputRegister(2);
 587       __ movsxlq(index, index);
 588       __ movq(Operand(object, index, times_1, 0), value);
 589       __ leaq(index, Operand(object, index, times_1, 0));
 590       SaveFPRegsMode mode =
 591           frame()->DidAllocateDoubleRegisters() ? kSaveFPRegs : kDontSaveFPRegs;
 592       __ RecordWrite(object, index, value, mode);
 593       break;
 594     }
 595   }
 596 }
 597
 598
 599 // Assembles branches after this instruction.
 600 void CodeGenerator::AssembleArchBranch(Instruction* instr,
 601                                        FlagsCondition condition) {
 602   X64OperandConverter i(this, instr);
 603   Label done;
 604
 605   // Emit a branch. The true and false targets are always the last two inputs
 606   // to the instruction.
 607   BasicBlock::RpoNumber tblock =
 608       i.InputRpo(static_cast<int>(instr->InputCount()) - 2);
 609   BasicBlock::RpoNumber fblock =
 610       i.InputRpo(static_cast<int>(instr->InputCount()) - 1);
 611   bool fallthru = IsNextInAssemblyOrder(fblock);
 612   Label* tlabel = code()->GetLabel(tblock);
 613   Label* flabel = fallthru ? &done : code()->GetLabel(fblock);
 614   Label::Distance flabel_distance = fallthru ? Label::kNear : Label::kFar;
 615   switch (condition) {
 616     case kUnorderedEqual:
 617       __ j(parity_even, flabel, flabel_distance);
 618     // Fall through.
 619     case kEqual:
 620       __ j(equal, tlabel);
 621       break;
 622     case kUnorderedNotEqual:
 623       __ j(parity_even, tlabel);
 624     // Fall through.
 625     case kNotEqual:
 626       __ j(not_equal, tlabel);
 627       break;
 628     case kSignedLessThan:
 629       __ j(less, tlabel);
 630       break;
 631     case kSignedGreaterThanOrEqual:
 632       __ j(greater_equal, tlabel);
 633       break;
 634     case kSignedLessThanOrEqual:
 635       __ j(less_equal, tlabel);
 636       break;
 637     case kSignedGreaterThan:
 638       __ j(greater, tlabel);
 639       break;
 640     case kUnorderedLessThan:
 641       __ j(parity_even, flabel, flabel_distance);
 642     // Fall through.
 643     case kUnsignedLessThan:
 644       __ j(below, tlabel);
 645       break;
 646     case kUnorderedGreaterThanOrEqual:
 647       __ j(parity_even, tlabel);
 648     // Fall through.
 649     case kUnsignedGreaterThanOrEqual:
 650       __ j(above_equal, tlabel);
 651       break;
 652     case kUnorderedLessThanOrEqual:
 653       __ j(parity_even, flabel, flabel_distance);
 654     // Fall through.
 655     case kUnsignedLessThanOrEqual:
 656       __ j(below_equal, tlabel);
 657       break;
 658     case kUnorderedGreaterThan:
 659       __ j(parity_even, tlabel);
 660     // Fall through.
 661     case kUnsignedGreaterThan:
 662       __ j(above, tlabel);
 663       break;
 664     case kOverflow:
 665       __ j(overflow, tlabel);
 666       break;
 667     case kNotOverflow:
 668       __ j(no_overflow, tlabel);
 669       break;
 670   }
 671   if (!fallthru) __ jmp(flabel, flabel_distance);  // no fallthru to flabel.
 672   __ bind(&done);
 673 }
 674
 675
 676 // Assembles boolean materializations after this instruction.
 677 void CodeGenerator::AssembleArchBoolean(Instruction* instr,
 678                                         FlagsCondition condition) {
 679   X64OperandConverter i(this, instr);
 680   Label done;
 681
 682   // Materialize a full 64-bit 1 or 0 value. The result register is always the
 683   // last output of the instruction.
 684   Label check;
 685   DCHECK_NE(0, static_cast<int>(instr->OutputCount()));
 686   Register reg = i.OutputRegister(static_cast<int>(instr->OutputCount() - 1));
 687   Condition cc = no_condition;
 688   switch (condition) {
 689     case kUnorderedEqual:
 690       __ j(parity_odd, &check, Label::kNear);
 691       __ movl(reg, Immediate(0));
 692       __ jmp(&done, Label::kNear);
 693     // Fall through.
 694     case kEqual:
 695       cc = equal;
 696       break;
 697     case kUnorderedNotEqual:
 698       __ j(parity_odd, &check, Label::kNear);
 699       __ movl(reg, Immediate(1));
 700       __ jmp(&done, Label::kNear);
 701     // Fall through.
 702     case kNotEqual:
 703       cc = not_equal;
 704       break;
 705     case kSignedLessThan:
 706       cc = less;
 707       break;
 708     case kSignedGreaterThanOrEqual:
 709       cc = greater_equal;
 710       break;
 711     case kSignedLessThanOrEqual:
 712       cc = less_equal;
 713       break;
 714     case kSignedGreaterThan:
 715       cc = greater;
 716       break;
 717     case kUnorderedLessThan:
 718       __ j(parity_odd, &check, Label::kNear);
 719       __ movl(reg, Immediate(0));
 720       __ jmp(&done, Label::kNear);
 721     // Fall through.
 722     case kUnsignedLessThan:
 723       cc = below;
 724       break;
 725     case kUnorderedGreaterThanOrEqual:
 726       __ j(parity_odd, &check, Label::kNear);
 727       __ movl(reg, Immediate(1));
 728       __ jmp(&done, Label::kNear);
 729     // Fall through.
 730     case kUnsignedGreaterThanOrEqual:
 731       cc = above_equal;
 732       break;
 733     case kUnorderedLessThanOrEqual:
 734       __ j(parity_odd, &check, Label::kNear);
 735       __ movl(reg, Immediate(0));
 736       __ jmp(&done, Label::kNear);
 737     // Fall through.
 738     case kUnsignedLessThanOrEqual:
 739       cc = below_equal;
 740       break;
 741     case kUnorderedGreaterThan:
 742       __ j(parity_odd, &check, Label::kNear);
 743       __ movl(reg, Immediate(1));
 744       __ jmp(&done, Label::kNear);
 745     // Fall through.
 746     case kUnsignedGreaterThan:
 747       cc = above;
 748       break;
 749     case kOverflow:
 750       cc = overflow;
 751       break;
 752     case kNotOverflow:
 753       cc = no_overflow;
 754       break;
 755   }
 756   __ bind(&check);
 757   __ setcc(cc, reg);
 758   __ movzxbl(reg, reg);
 759   __ bind(&done);
 760 }
 761
 762
 763 void CodeGenerator::AssembleDeoptimizerCall(int deoptimization_id) {
 764   Address deopt_entry = Deoptimizer::GetDeoptimizationEntry(
 765       isolate(), deoptimization_id, Deoptimizer::LAZY);
 766   __ call(deopt_entry, RelocInfo::RUNTIME_ENTRY);
 767 }
 768
 769
 770 void CodeGenerator::AssemblePrologue() {
 771   CallDescriptor* descriptor = linkage()->GetIncomingDescriptor();
 772   int stack_slots = frame()->GetSpillSlotCount();
 773   if (descriptor->kind() == CallDescriptor::kCallAddress) {
 774     __ pushq(rbp);
 775     __ movq(rbp, rsp);
 776     const RegList saves = descriptor->CalleeSavedRegisters();
 777     if (saves != 0) {  // Save callee-saved registers.
 778       int register_save_area_size = 0;
 779       for (int i = Register::kNumRegisters - 1; i >= 0; i--) {
 780         if (!((1 << i) & saves)) continue;
 781         __ pushq(Register::from_code(i));
 782         register_save_area_size += kPointerSize;
 783       }
 784       frame()->SetRegisterSaveAreaSize(register_save_area_size);
 785     }
 786   } else if (descriptor->IsJSFunctionCall()) {
 787     CompilationInfo* info = this->info();
 788     __ Prologue(info->IsCodePreAgingActive());
 789     frame()->SetRegisterSaveAreaSize(
 790         StandardFrameConstants::kFixedFrameSizeFromFp);
 791
 792     // Sloppy mode functions and builtins need to replace the receiver with the
 793     // global proxy when called as functions (without an explicit receiver
 794     // object).
 795     // TODO(mstarzinger/verwaest): Should this be moved back into the CallIC?
 796     if (info->strict_mode() == SLOPPY && !info->is_native()) {
 797       Label ok;
 798       StackArgumentsAccessor args(rbp, info->scope()->num_parameters());
 799       __ movp(rcx, args.GetReceiverOperand());
 800       __ CompareRoot(rcx, Heap::kUndefinedValueRootIndex);
 801       __ j(not_equal, &ok, Label::kNear);
 802       __ movp(rcx, GlobalObjectOperand());
 803       __ movp(rcx, FieldOperand(rcx, GlobalObject::kGlobalProxyOffset));
 804       __ movp(args.GetReceiverOperand(), rcx);
 805       __ bind(&ok);
 806     }
 807
 808   } else {
 809     __ StubPrologue();
 810     frame()->SetRegisterSaveAreaSize(
 811         StandardFrameConstants::kFixedFrameSizeFromFp);
 812   }
 813   if (stack_slots > 0) {
 814     __ subq(rsp, Immediate(stack_slots * kPointerSize));
 815   }
 816 }
 817
 818
 819 void CodeGenerator::AssembleReturn() {
 820   CallDescriptor* descriptor = linkage()->GetIncomingDescriptor();
 821   if (descriptor->kind() == CallDescriptor::kCallAddress) {
 822     if (frame()->GetRegisterSaveAreaSize() > 0) {
 823       // Remove this frame's spill slots first.
 824       int stack_slots = frame()->GetSpillSlotCount();
 825       if (stack_slots > 0) {
 826         __ addq(rsp, Immediate(stack_slots * kPointerSize));
 827       }
 828       const RegList saves = descriptor->CalleeSavedRegisters();
 829       // Restore registers.
 830       if (saves != 0) {
 831         for (int i = 0; i < Register::kNumRegisters; i++) {
 832           if (!((1 << i) & saves)) continue;
 833           __ popq(Register::from_code(i));
 834         }
 835       }
 836       __ popq(rbp);  // Pop caller's frame pointer.
 837       __ ret(0);
 838     } else {
 839       // No saved registers.
 840       __ movq(rsp, rbp);  // Move stack pointer back to frame pointer.
 841       __ popq(rbp);       // Pop caller's frame pointer.
 842       __ ret(0);
 843     }
 844   } else {
 845     __ movq(rsp, rbp);  // Move stack pointer back to frame pointer.
 846     __ popq(rbp);       // Pop caller's frame pointer.
 847     int pop_count = descriptor->IsJSFunctionCall()
 848                         ? static_cast<int>(descriptor->JSParameterCount())
 849                         : 0;
 850     __ ret(pop_count * kPointerSize);
 851   }
 852 }
 853
 854
 855 void CodeGenerator::AssembleMove(InstructionOperand* source,
 856                                  InstructionOperand* destination) {
 857   X64OperandConverter g(this, NULL);
 858   // Dispatch on the source and destination operand kinds.  Not all
 859   // combinations are possible.
 860   if (source->IsRegister()) {
 861     DCHECK(destination->IsRegister() || destination->IsStackSlot());
 862     Register src = g.ToRegister(source);
 863     if (destination->IsRegister()) {
 864       __ movq(g.ToRegister(destination), src);
 865     } else {
 866       __ movq(g.ToOperand(destination), src);
 867     }
 868   } else if (source->IsStackSlot()) {
 869     DCHECK(destination->IsRegister() || destination->IsStackSlot());
 870     Operand src = g.ToOperand(source);
 871     if (destination->IsRegister()) {
 872       Register dst = g.ToRegister(destination);
 873       __ movq(dst, src);
 874     } else {
 875       // Spill on demand to use a temporary register for memory-to-memory
 876       // moves.
 877       Register tmp = kScratchRegister;
 878       Operand dst = g.ToOperand(destination);
 879       __ movq(tmp, src);
 880       __ movq(dst, tmp);
 881     }
 882   } else if (source->IsConstant()) {
 883     ConstantOperand* constant_source = ConstantOperand::cast(source);
 884     Constant src = g.ToConstant(constant_source);
 885     if (destination->IsRegister() || destination->IsStackSlot()) {
 886       Register dst = destination->IsRegister() ? g.ToRegister(destination)
 887                                                : kScratchRegister;
 888       switch (src.type()) {
 889         case Constant::kInt32:
 890           // TODO(dcarney): don't need scratch in this case.
 891           __ Set(dst, src.ToInt32());
 892           break;
 893         case Constant::kInt64:
 894           __ Set(dst, src.ToInt64());
 895           break;
 896         case Constant::kFloat32:
 897           __ Move(dst,
 898                   isolate()->factory()->NewNumber(src.ToFloat32(), TENURED));
 899           break;
 900         case Constant::kFloat64:
 901           __ Move(dst,
 902                   isolate()->factory()->NewNumber(src.ToFloat64(), TENURED));
 903           break;
 904         case Constant::kExternalReference:
 905           __ Move(dst, src.ToExternalReference());
 906           break;
 907         case Constant::kHeapObject:
 908           __ Move(dst, src.ToHeapObject());
 909           break;
 910       }
 911       if (destination->IsStackSlot()) {
 912         __ movq(g.ToOperand(destination), kScratchRegister);
 913       }
 914     } else if (src.type() == Constant::kFloat32) {
 915       // TODO(turbofan): Can we do better here?
 916       uint32_t src_const = bit_cast<uint32_t>(src.ToFloat32());
 917       if (destination->IsDoubleRegister()) {
 918         __ Move(g.ToDoubleRegister(destination), src_const);
 919       } else {
 920         DCHECK(destination->IsDoubleStackSlot());
 921         Operand dst = g.ToOperand(destination);
 922         __ movl(dst, Immediate(src_const));
 923       }
 924     } else {
 925       DCHECK_EQ(Constant::kFloat64, src.type());
 926       uint64_t src_const = bit_cast<uint64_t>(src.ToFloat64());
 927       if (destination->IsDoubleRegister()) {
 928         __ Move(g.ToDoubleRegister(destination), src_const);
 929       } else {
 930         DCHECK(destination->IsDoubleStackSlot());
 931         __ movq(kScratchRegister, src_const);
 932         __ movq(g.ToOperand(destination), kScratchRegister);
 933       }
 934     }
 935   } else if (source->IsDoubleRegister()) {
 936     XMMRegister src = g.ToDoubleRegister(source);
 937     if (destination->IsDoubleRegister()) {
 938       XMMRegister dst = g.ToDoubleRegister(destination);
 939       __ movsd(dst, src);
 940     } else {
 941       DCHECK(destination->IsDoubleStackSlot());
 942       Operand dst = g.ToOperand(destination);
 943       __ movsd(dst, src);
 944     }
 945   } else if (source->IsDoubleStackSlot()) {
 946     DCHECK(destination->IsDoubleRegister() || destination->IsDoubleStackSlot());
 947     Operand src = g.ToOperand(source);
 948     if (destination->IsDoubleRegister()) {
 949       XMMRegister dst = g.ToDoubleRegister(destination);
 950       __ movsd(dst, src);
 951     } else {
 952       // We rely on having xmm0 available as a fixed scratch register.
 953       Operand dst = g.ToOperand(destination);
 954       __ movsd(xmm0, src);
 955       __ movsd(dst, xmm0);
 956     }
 957   } else {
 958     UNREACHABLE();
 959   }
 960 }
 961
 962
 963 void CodeGenerator::AssembleSwap(InstructionOperand* source,
 964                                  InstructionOperand* destination) {
 965   X64OperandConverter g(this, NULL);
 966   // Dispatch on the source and destination operand kinds.  Not all
 967   // combinations are possible.
 968   if (source->IsRegister() && destination->IsRegister()) {
 969     // Register-register.
 970     __ xchgq(g.ToRegister(source), g.ToRegister(destination));
 971   } else if (source->IsRegister() && destination->IsStackSlot()) {
 972     Register src = g.ToRegister(source);
 973     Operand dst = g.ToOperand(destination);
 974     __ xchgq(src, dst);
 975   } else if ((source->IsStackSlot() && destination->IsStackSlot()) ||
 976              (source->IsDoubleStackSlot() &&
 977               destination->IsDoubleStackSlot())) {
 978     // Memory-memory.
 979     Register tmp = kScratchRegister;
 980     Operand src = g.ToOperand(source);
 981     Operand dst = g.ToOperand(destination);
 982     __ movq(tmp, dst);
 983     __ xchgq(tmp, src);
 984     __ movq(dst, tmp);
 985   } else if (source->IsDoubleRegister() && destination->IsDoubleRegister()) {
 986     // XMM register-register swap. We rely on having xmm0
 987     // available as a fixed scratch register.
 988     XMMRegister src = g.ToDoubleRegister(source);
 989     XMMRegister dst = g.ToDoubleRegister(destination);
 990     __ movsd(xmm0, src);
 991     __ movsd(src, dst);
 992     __ movsd(dst, xmm0);
 993   } else if (source->IsDoubleRegister() && destination->IsDoubleRegister()) {
 994     // XMM register-memory swap.  We rely on having xmm0
 995     // available as a fixed scratch register.
 996     XMMRegister src = g.ToDoubleRegister(source);
 997     Operand dst = g.ToOperand(destination);
 998     __ movsd(xmm0, src);
 999     __ movsd(src, dst);
1000     __ movsd(dst, xmm0);
1001   } else {
1002     // No other combinations are possible.
1003     UNREACHABLE();
1004   }
1005 }
1006
1007
1008 void CodeGenerator::AddNopForSmiCodeInlining() { __ nop(); }
1009
1010
1011 void CodeGenerator::EnsureSpaceForLazyDeopt() {
1012   int space_needed = Deoptimizer::patch_size();
1013   if (!info()->IsStub()) {
1014     // Ensure that we have enough space after the previous lazy-bailout
1015     // instruction for patching the code here.
1016     int current_pc = masm()->pc_offset();
1017     if (current_pc < last_lazy_deopt_pc_ + space_needed) {
1018       int padding_size = last_lazy_deopt_pc_ + space_needed - current_pc;
1019       __ Nop(padding_size);
1020     }
1021   }
1022   MarkLazyDeoptSite();
1023 }
1024
1025 #undef __
1026
1027 }  // namespace internal
1028 }  // namespace compiler
1029 }  // namespace v8