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