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