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