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