[turbofan]: Elide extra move when accessing stack or frame register

src/compiler/x64/code-generator-x64.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/code-generator.h"
 
 #include "src/compiler/code-generator-impl.h"
 #include "src/compiler/gap-resolver.h"
 #include "src/compiler/node-matchers.h"
 #include "src/scopes.h"
@@ skipping 175 matching lines @@
   }
 
  private:
   Register const result_;
   XMMRegister const input_;
 };
 
 }  // namespace
 
 
-#define ASSEMBLE_UNOP(asm_instr)         \
-  do {                                   \
-    if (instr->Output()->IsRegister()) { \
-      __ asm_instr(i.OutputRegister());  \
-    } else {                             \
-      __ asm_instr(i.OutputOperand());   \
-    }                                    \
+#define ASSEMBLE_UNOP(asm_instr)                \
+  do {                                          \
+    if (instr->Output()->GeneratesRegister()) { \
+      __ asm_instr(i.OutputRegister());         \
+    } else {                                    \
+      __ asm_instr(i.OutputOperand());          \
+    }                                           \
   } while (0)
 
 
 #define ASSEMBLE_BINOP(asm_instr)                              \
   do {                                                         \
     if (HasImmediateInput(instr, 1)) {                         \
-      if (instr->InputAt(0)->IsRegister()) {                   \
+      if (instr->InputAt(0)->GeneratesRegister()) {            \
         __ asm_instr(i.InputRegister(0), i.InputImmediate(1)); \
       } else {                                                 \
         __ asm_instr(i.InputOperand(0), i.InputImmediate(1));  \
       }                                                        \
     } else {                                                   \
-      if (instr->InputAt(1)->IsRegister()) {                   \
+      if (instr->InputAt(1)->GeneratesRegister()) {            \
         __ asm_instr(i.InputRegister(0), i.InputRegister(1));  \
       } else {                                                 \
         __ asm_instr(i.InputRegister(0), i.InputOperand(1));   \
       }                                                        \
     }                                                          \
   } while (0)
 
 
 #define ASSEMBLE_MULT(asm_instr)                              \
   do {                                                        \
     if (HasImmediateInput(instr, 1)) {                        \
-      if (instr->InputAt(0)->IsRegister()) {                  \
+      if (instr->InputAt(0)->GeneratesRegister()) {           \
         __ asm_instr(i.OutputRegister(), i.InputRegister(0),  \
                      i.InputImmediate(1));                    \
       } else {                                                \
         __ asm_instr(i.OutputRegister(), i.InputOperand(0),   \
                      i.InputImmediate(1));                    \
       }                                                       \
     } else {                                                  \
-      if (instr->InputAt(1)->IsRegister()) {                  \
+      if (instr->InputAt(1)->GeneratesRegister()) {           \
         __ asm_instr(i.OutputRegister(), i.InputRegister(1)); \
       } else {                                                \
         __ asm_instr(i.OutputRegister(), i.InputOperand(1));  \
       }                                                       \
     }                                                         \
   } while (0)
 
 
 #define ASSEMBLE_SHIFT(asm_instr, width)                                   \
   do {                                                                     \
     if (HasImmediateInput(instr, 1)) {                                     \
-      if (instr->Output()->IsRegister()) {                                 \
+      if (instr->Output()->GeneratesRegister()) {                          \
         __ asm_instr(i.OutputRegister(), Immediate(i.InputInt##width(1))); \
       } else {                                                             \
         __ asm_instr(i.OutputOperand(), Immediate(i.InputInt##width(1)));  \
       }                                                                    \
     } else {                                                               \
-      if (instr->Output()->IsRegister()) {                                 \
+      if (instr->Output()->GeneratesRegister()) {                          \
         __ asm_instr##_cl(i.OutputRegister());                             \
       } else {                                                             \
         __ asm_instr##_cl(i.OutputOperand());                              \
       }                                                                    \
     }                                                                      \
   } while (0)
 
 
 #define ASSEMBLE_MOVX(asm_instr)                            \
   do {                                                      \
     if (instr->addressing_mode() != kMode_None) {           \
       __ asm_instr(i.OutputRegister(), i.MemoryOperand());  \
-    } else if (instr->InputAt(0)->IsRegister()) {           \
+    } else if (instr->InputAt(0)->GeneratesRegister()) {    \
       __ asm_instr(i.OutputRegister(), i.InputRegister(0)); \
     } else {                                                \
       __ asm_instr(i.OutputRegister(), i.InputOperand(0));  \
     }                                                       \
   } while (0)
 
 
 #define ASSEMBLE_SSE_BINOP(asm_instr)                                   \
   do {                                                                  \
     if (instr->InputAt(1)->IsDoubleRegister()) {                        \
@@ skipping 27 matching lines @@
   } while (0)
 
 
 #define ASSEMBLE_CHECKED_LOAD_FLOAT(asm_instr)                               \
   do {                                                                       \
     auto result = i.OutputDoubleRegister();                                  \
     auto buffer = i.InputRegister(0);                                        \
     auto index1 = i.InputRegister(1);                                        \
     auto index2 = i.InputInt32(2);                                           \
     OutOfLineCode* ool;                                                      \
-    if (instr->InputAt(3)->IsRegister()) {                                   \
+    if (instr->InputAt(3)->GeneratesRegister()) {                            \
       auto length = i.InputRegister(3);                                      \
       DCHECK_EQ(0, index2);                                                  \
       __ cmpl(index1, length);                                               \
       ool = new (zone()) OutOfLineLoadNaN(this, result);                     \
     } else {                                                                 \
       auto length = i.InputInt32(3);                                         \
       DCHECK_LE(index2, length);                                             \
       __ cmpq(index1, Immediate(length - index2));                           \
       class OutOfLineLoadFloat final : public OutOfLineCode {                \
        public:                                                               \
@@ skipping 32 matching lines @@
   } while (false)
 
 
 #define ASSEMBLE_CHECKED_LOAD_INTEGER(asm_instr)                               \
   do {                                                                         \
     auto result = i.OutputRegister();                                          \
     auto buffer = i.InputRegister(0);                                          \
     auto index1 = i.InputRegister(1);                                          \
     auto index2 = i.InputInt32(2);                                             \
     OutOfLineCode* ool;                                                        \
-    if (instr->InputAt(3)->IsRegister()) {                                     \
+    if (instr->InputAt(3)->GeneratesRegister()) {                              \
       auto length = i.InputRegister(3);                                        \
       DCHECK_EQ(0, index2);                                                    \
       __ cmpl(index1, length);                                                 \
       ool = new (zone()) OutOfLineLoadZero(this, result);                      \
     } else {                                                                   \
       auto length = i.InputInt32(3);                                           \
       DCHECK_LE(index2, length);                                               \
       __ cmpq(index1, Immediate(length - index2));                             \
       class OutOfLineLoadInteger final : public OutOfLineCode {                \
        public:                                                                 \
@@ skipping 34 matching lines @@
     __ bind(ool->exit());                                                      \
   } while (false)
 
 
 #define ASSEMBLE_CHECKED_STORE_FLOAT(asm_instr)                              \
   do {                                                                       \
     auto buffer = i.InputRegister(0);                                        \
     auto index1 = i.InputRegister(1);                                        \
     auto index2 = i.InputInt32(2);                                           \
     auto value = i.InputDoubleRegister(4);                                   \
-    if (instr->InputAt(3)->IsRegister()) {                                   \
+    if (instr->InputAt(3)->GeneratesRegister()) {                            \
       auto length = i.InputRegister(3);                                      \
       DCHECK_EQ(0, index2);                                                  \
       Label done;                                                            \
       __ cmpl(index1, length);                                               \
       __ j(above_equal, &done, Label::kNear);                                \
       __ asm_instr(Operand(buffer, index1, times_1, index2), value);         \
       __ bind(&done);                                                        \
     } else {                                                                 \
       auto length = i.InputInt32(3);                                         \
       DCHECK_LE(index2, length);                                             \
@@ skipping 32 matching lines @@
       __ bind(ool->exit());                                                  \
     }                                                                        \
   } while (false)
 
 
 #define ASSEMBLE_CHECKED_STORE_INTEGER_IMPL(asm_instr, Value)                  \
   do {                                                                         \
     auto buffer = i.InputRegister(0);                                          \
     auto index1 = i.InputRegister(1);                                          \
     auto index2 = i.InputInt32(2);                                             \
-    if (instr->InputAt(3)->IsRegister()) {                                     \
+    if (instr->InputAt(3)->GeneratesRegister()) {                              \
       auto length = i.InputRegister(3);                                        \
       DCHECK_EQ(0, index2);                                                    \
       Label done;                                                              \
       __ cmpl(index1, length);                                                 \
       __ j(above_equal, &done, Label::kNear);                                  \
       __ asm_instr(Operand(buffer, index1, times_1, index2), value);           \
       __ bind(&done);                                                          \
     } else {                                                                   \
       auto length = i.InputInt32(3);                                           \
       DCHECK_LE(index2, length);                                               \
@@ skipping 29 matching lines @@
           OutOfLineStoreInteger(this, buffer, index1, index2, length, value);  \
       __ j(above_equal, ool->entry());                                         \
       __ asm_instr(Operand(buffer, index1, times_1, index2), value);           \
       __ bind(ool->exit());                                                    \
     }                                                                          \
   } while (false)
 
 
 #define ASSEMBLE_CHECKED_STORE_INTEGER(asm_instr)                \
   do {                                                           \
-    if (instr->InputAt(4)->IsRegister()) {                       \
+    if (instr->InputAt(4)->GeneratesRegister()) {                \
       Register value = i.InputRegister(4);                       \
       ASSEMBLE_CHECKED_STORE_INTEGER_IMPL(asm_instr, Register);  \
     } else {                                                     \
       Immediate value = i.InputImmediate(4);                     \
       ASSEMBLE_CHECKED_STORE_INTEGER_IMPL(asm_instr, Immediate); \
     }                                                            \
   } while (false)
 
 
 void CodeGenerator::AssembleDeconstructActivationRecord() {
@@ skipping 142 matching lines @@
     case kX64Test:
       ASSEMBLE_BINOP(testq);
       break;
     case kX64Imul32:
       ASSEMBLE_MULT(imull);
       break;
     case kX64Imul:
       ASSEMBLE_MULT(imulq);
       break;
     case kX64ImulHigh32:
-      if (instr->InputAt(1)->IsRegister()) {
+      if (instr->InputAt(1)->GeneratesRegister()) {
         __ imull(i.InputRegister(1));
       } else {
         __ imull(i.InputOperand(1));
       }
       break;
     case kX64UmulHigh32:
-      if (instr->InputAt(1)->IsRegister()) {
+      if (instr->InputAt(1)->GeneratesRegister()) {
         __ mull(i.InputRegister(1));
       } else {
         __ mull(i.InputOperand(1));
       }
       break;
     case kX64Idiv32:
       __ cdq();
       __ idivl(i.InputRegister(1));
       break;
     case kX64Idiv:
@@ skipping 50 matching lines @@
     case kX64Sar:
       ASSEMBLE_SHIFT(sarq, 6);
       break;
     case kX64Ror32:
       ASSEMBLE_SHIFT(rorl, 5);
       break;
     case kX64Ror:
       ASSEMBLE_SHIFT(rorq, 6);
       break;
     case kX64Lzcnt32:
-      if (instr->InputAt(0)->IsRegister()) {
+      if (instr->InputAt(0)->GeneratesRegister()) {
         __ Lzcntl(i.OutputRegister(), i.InputRegister(0));
       } else {
         __ Lzcntl(i.OutputRegister(), i.InputOperand(0));
       }
       break;
     case kSSEFloat32Cmp:
       ASSEMBLE_SSE_BINOP(ucomiss);
       break;
     case kSSEFloat32Add:
       ASSEMBLE_SSE_BINOP(addss);
@@ skipping 129 matching lines @@
     case kSSEFloat64ToUint32: {
       if (instr->InputAt(0)->IsDoubleRegister()) {
         __ cvttsd2siq(i.OutputRegister(), i.InputDoubleRegister(0));
       } else {
         __ cvttsd2siq(i.OutputRegister(), i.InputOperand(0));
       }
       __ AssertZeroExtended(i.OutputRegister());
       break;
     }
     case kSSEInt32ToFloat64:
-      if (instr->InputAt(0)->IsRegister()) {
+      if (instr->InputAt(0)->GeneratesRegister()) {
         __ cvtlsi2sd(i.OutputDoubleRegister(), i.InputRegister(0));
       } else {
         __ cvtlsi2sd(i.OutputDoubleRegister(), i.InputOperand(0));
       }
       break;
     case kSSEUint32ToFloat64:
-      if (instr->InputAt(0)->IsRegister()) {
+      if (instr->InputAt(0)->GeneratesRegister()) {
         __ movl(kScratchRegister, i.InputRegister(0));
       } else {
         __ movl(kScratchRegister, i.InputOperand(0));
       }
       __ cvtqsi2sd(i.OutputDoubleRegister(), kScratchRegister);
       break;
     case kSSEFloat64ExtractLowWord32:
       if (instr->InputAt(0)->IsDoubleStackSlot()) {
         __ movl(i.OutputRegister(), i.InputOperand(0));
       } else {
         __ movd(i.OutputRegister(), i.InputDoubleRegister(0));
       }
       break;
     case kSSEFloat64ExtractHighWord32:
       if (instr->InputAt(0)->IsDoubleStackSlot()) {
         __ movl(i.OutputRegister(), i.InputOperand(0, kDoubleSize / 2));
       } else {
         __ Pextrd(i.OutputRegister(), i.InputDoubleRegister(0), 1);
       }
       break;
     case kSSEFloat64InsertLowWord32:
-      if (instr->InputAt(1)->IsRegister()) {
+      if (instr->InputAt(1)->GeneratesRegister()) {
         __ Pinsrd(i.OutputDoubleRegister(), i.InputRegister(1), 0);
       } else {
         __ Pinsrd(i.OutputDoubleRegister(), i.InputOperand(1), 0);
       }
       break;
     case kSSEFloat64InsertHighWord32:
-      if (instr->InputAt(1)->IsRegister()) {
+      if (instr->InputAt(1)->GeneratesRegister()) {
         __ Pinsrd(i.OutputDoubleRegister(), i.InputRegister(1), 1);
       } else {
         __ Pinsrd(i.OutputDoubleRegister(), i.InputOperand(1), 1);
       }
       break;
     case kSSEFloat64LoadLowWord32:
-      if (instr->InputAt(0)->IsRegister()) {
+      if (instr->InputAt(0)->GeneratesRegister()) {
         __ movd(i.OutputDoubleRegister(), i.InputRegister(0));
       } else {
         __ movd(i.OutputDoubleRegister(), i.InputOperand(0));
       }
       break;
     case kAVXFloat32Cmp: {
       CpuFeatureScope avx_scope(masm(), AVX);
       if (instr->InputAt(1)->IsDoubleRegister()) {
         __ vucomiss(i.InputDoubleRegister(0), i.InputDoubleRegister(1));
       } else {
@@ skipping 140 matching lines @@
       if (HasImmediateInput(instr, index)) {
         __ movw(operand, Immediate(i.InputInt16(index)));
       } else {
         __ movw(operand, i.InputRegister(index));
       }
       break;
     }
     case kX64Movl:
       if (instr->HasOutput()) {
         if (instr->addressing_mode() == kMode_None) {
-          if (instr->InputAt(0)->IsRegister()) {
+          if (instr->InputAt(0)->GeneratesRegister()) {
             __ movl(i.OutputRegister(), i.InputRegister(0));
           } else {
             __ movl(i.OutputRegister(), i.InputOperand(0));
           }
         } else {
           __ movl(i.OutputRegister(), i.MemoryOperand());
         }
         __ AssertZeroExtended(i.OutputRegister());
       } else {
         size_t index = 0;
@@ skipping 79 matching lines @@
     case kX64Dec32:
       __ decl(i.OutputRegister());
       break;
     case kX64Inc32:
       __ incl(i.OutputRegister());
       break;
     case kX64Push:
       if (HasImmediateInput(instr, 0)) {
         __ pushq(i.InputImmediate(0));
       } else {
-        if (instr->InputAt(0)->IsRegister()) {
+        if (instr->InputAt(0)->GeneratesRegister()) {
           __ pushq(i.InputRegister(0));
         } else {
           __ pushq(i.InputOperand(0));
         }
       }
       break;
     case kX64Poke: {
       int const slot = MiscField::decode(instr->opcode());
       if (HasImmediateInput(instr, 0)) {
         __ movq(Operand(rsp, slot * kPointerSize), i.InputImmediate(0));
@@ skipping 353 matching lines @@
     __ Ret();
   }
 }
 
 
 void CodeGenerator::AssembleMove(InstructionOperand* source,
                                  InstructionOperand* destination) {
   X64OperandConverter g(this, NULL);
   // Dispatch on the source and destination operand kinds.  Not all
   // combinations are possible.
-  if (source->IsRegister()) {
-    DCHECK(destination->IsRegister() || destination->IsStackSlot());
+  if (source->GeneratesRegister()) {
+    DCHECK(destination->GeneratesRegister() || destination->IsStackSlot());
     Register src = g.ToRegister(source);
-    if (destination->IsRegister()) {
+    if (destination->GeneratesRegister()) {
       __ movq(g.ToRegister(destination), src);
     } else {
       __ movq(g.ToOperand(destination), src);
     }
   } else if (source->IsStackSlot()) {
-    DCHECK(destination->IsRegister() || destination->IsStackSlot());
+    DCHECK(destination->GeneratesRegister() || destination->IsStackSlot());
     Operand src = g.ToOperand(source);
-    if (destination->IsRegister()) {
+    if (destination->GeneratesRegister()) {
       Register dst = g.ToRegister(destination);
       __ movq(dst, src);
     } else {
       // Spill on demand to use a temporary register for memory-to-memory
       // moves.
       Register tmp = kScratchRegister;
       Operand dst = g.ToOperand(destination);
       __ movq(tmp, src);
       __ movq(dst, tmp);
     }
   } else if (source->IsConstant()) {
     ConstantOperand* constant_source = ConstantOperand::cast(source);
     Constant src = g.ToConstant(constant_source);
-    if (destination->IsRegister() || destination->IsStackSlot()) {
-      Register dst = destination->IsRegister() ? g.ToRegister(destination)
-                                               : kScratchRegister;
+    if (destination->GeneratesRegister() || destination->IsStackSlot()) {
+      Register dst = destination->GeneratesRegister()
+                         ? g.ToRegister(destination)
+                         : kScratchRegister;
       switch (src.type()) {
         case Constant::kInt32:
           // TODO(dcarney): don't need scratch in this case.
           __ Set(dst, src.ToInt32());
           break;
         case Constant::kInt64:
           __ Set(dst, src.ToInt64());
           break;
         case Constant::kFloat32:
           __ Move(dst,
@@ skipping 73 matching lines @@
     UNREACHABLE();
   }
 }
 
 
 void CodeGenerator::AssembleSwap(InstructionOperand* source,
                                  InstructionOperand* destination) {
   X64OperandConverter g(this, NULL);
   // Dispatch on the source and destination operand kinds.  Not all
   // combinations are possible.
-  if (source->IsRegister() && destination->IsRegister()) {
+  if (source->GeneratesRegister() && destination->GeneratesRegister()) {
     // Register-register.
     __ xchgq(g.ToRegister(source), g.ToRegister(destination));
-  } else if (source->IsRegister() && destination->IsStackSlot()) {
+  } else if (source->GeneratesRegister() && destination->IsStackSlot()) {
     Register src = g.ToRegister(source);
     Operand dst = g.ToOperand(destination);
     __ xchgq(src, dst);
   } else if ((source->IsStackSlot() && destination->IsStackSlot()) ||
              (source->IsDoubleStackSlot() &&
               destination->IsDoubleStackSlot())) {
     // Memory-memory.
     Register tmp = kScratchRegister;
     Operand src = g.ToOperand(source);
     Operand dst = g.ToOperand(destination);
@@ skipping 44 matching lines @@
       __ Nop(padding_size);
     }
   }
 }
 
 #undef __
 
 }  // namespace internal
 }  // namespace compiler
 }  // namespace v8