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

src/compiler/ia32/code-generator-ia32.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/ia32/assembler-ia32.h"
@@ skipping 20 matching lines @@
     return ToOperand(instr_->InputAt(index), extra);
   }
 
   Immediate InputImmediate(size_t index) {
     return ToImmediate(instr_->InputAt(index));
   }
 
   Operand OutputOperand() { return ToOperand(instr_->Output()); }
 
   Operand ToOperand(InstructionOperand* op, int extra = 0) {
-    if (op->IsRegister()) {
+    if (op->GeneratesRegister()) {
       DCHECK(extra == 0);
       return Operand(ToRegister(op));
     } else if (op->IsDoubleRegister()) {
       DCHECK(extra == 0);
       return Operand(ToDoubleRegister(op));
     }
     DCHECK(op->IsStackSlot() || op->IsDoubleStackSlot());
     // The linkage computes where all spill slots are located.
     FrameOffset offset = linkage()->GetFrameOffset(
         AllocatedOperand::cast(op)->index(), frame(), extra);
@@ skipping 163 matching lines @@
   XMMRegister const input_;
 };
 
 }  // namespace
 
 
 #define ASSEMBLE_CHECKED_LOAD_FLOAT(asm_instr)                          \
   do {                                                                  \
     auto result = i.OutputDoubleRegister();                             \
     auto offset = i.InputRegister(0);                                   \
-    if (instr->InputAt(1)->IsRegister()) {                              \
+    if (instr->InputAt(1)->GeneratesRegister()) {                       \
       __ cmp(offset, i.InputRegister(1));                               \
     } else {                                                            \
       __ cmp(offset, i.InputImmediate(1));                              \
     }                                                                   \
     OutOfLineCode* ool = new (zone()) OutOfLineLoadFloat(this, result); \
     __ j(above_equal, ool->entry());                                    \
     __ asm_instr(result, i.MemoryOperand(2));                           \
     __ bind(ool->exit());                                               \
   } while (false)
 
 
 #define ASSEMBLE_CHECKED_LOAD_INTEGER(asm_instr)                          \
   do {                                                                    \
     auto result = i.OutputRegister();                                     \
     auto offset = i.InputRegister(0);                                     \
-    if (instr->InputAt(1)->IsRegister()) {                                \
+    if (instr->InputAt(1)->GeneratesRegister()) {                         \
       __ cmp(offset, i.InputRegister(1));                                 \
     } else {                                                              \
       __ cmp(offset, i.InputImmediate(1));                                \
     }                                                                     \
     OutOfLineCode* ool = new (zone()) OutOfLineLoadInteger(this, result); \
     __ j(above_equal, ool->entry());                                      \
     __ asm_instr(result, i.MemoryOperand(2));                             \
     __ bind(ool->exit());                                                 \
   } while (false)
 
 
 #define ASSEMBLE_CHECKED_STORE_FLOAT(asm_instr)                 \
   do {                                                          \
     auto offset = i.InputRegister(0);                           \
-    if (instr->InputAt(1)->IsRegister()) {                      \
+    if (instr->InputAt(1)->GeneratesRegister()) {               \
       __ cmp(offset, i.InputRegister(1));                       \
     } else {                                                    \
       __ cmp(offset, i.InputImmediate(1));                      \
     }                                                           \
     Label done;                                                 \
     __ j(above_equal, &done, Label::kNear);                     \
     __ asm_instr(i.MemoryOperand(3), i.InputDoubleRegister(2)); \
     __ bind(&done);                                             \
   } while (false)
 
 
 #define ASSEMBLE_CHECKED_STORE_INTEGER(asm_instr)            \
   do {                                                       \
     auto offset = i.InputRegister(0);                        \
-    if (instr->InputAt(1)->IsRegister()) {                   \
+    if (instr->InputAt(1)->GeneratesRegister()) {            \
       __ cmp(offset, i.InputRegister(1));                    \
     } else {                                                 \
       __ cmp(offset, i.InputImmediate(1));                   \
     }                                                        \
     Label done;                                              \
     __ j(above_equal, &done, Label::kNear);                  \
-    if (instr->InputAt(2)->IsRegister()) {                   \
+    if (instr->InputAt(2)->GeneratesRegister()) {            \
       __ asm_instr(i.MemoryOperand(3), i.InputRegister(2));  \
     } else {                                                 \
       __ asm_instr(i.MemoryOperand(3), i.InputImmediate(2)); \
     }                                                        \
     __ bind(&done);                                          \
   } while (false)
 
 
 void CodeGenerator::AssembleDeconstructActivationRecord() {
   CallDescriptor* descriptor = linkage()->GetIncomingDescriptor();
@@ skipping 1065 matching lines @@
     __ ret(0);
   }
 }
 
 
 void CodeGenerator::AssembleMove(InstructionOperand* source,
                                  InstructionOperand* destination) {
   IA32OperandConverter 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);
     Operand dst = g.ToOperand(destination);
     __ mov(dst, 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);
       __ mov(dst, src);
     } else {
       Operand dst = g.ToOperand(destination);
       __ push(src);
       __ pop(dst);
     }
   } else if (source->IsConstant()) {
     Constant src_constant = g.ToConstant(source);
     if (src_constant.type() == Constant::kHeapObject) {
       Handle<HeapObject> src = src_constant.ToHeapObject();
       int offset;
       if (IsMaterializableFromFrame(src, &offset)) {
-        if (destination->IsRegister()) {
+        if (destination->GeneratesRegister()) {
           Register dst = g.ToRegister(destination);
           __ mov(dst, Operand(ebp, offset));
         } else {
           DCHECK(destination->IsStackSlot());
           Operand dst = g.ToOperand(destination);
           __ push(Operand(ebp, offset));
           __ pop(dst);
         }
-      } else if (destination->IsRegister()) {
+      } else if (destination->GeneratesRegister()) {
         Register dst = g.ToRegister(destination);
         __ LoadHeapObject(dst, src);
       } else {
         DCHECK(destination->IsStackSlot());
         Operand dst = g.ToOperand(destination);
         AllowDeferredHandleDereference embedding_raw_address;
         if (isolate()->heap()->InNewSpace(*src)) {
           __ PushHeapObject(src);
           __ pop(dst);
         } else {
           __ mov(dst, src);
         }
       }
-    } else if (destination->IsRegister()) {
+    } else if (destination->GeneratesRegister()) {
       Register dst = g.ToRegister(destination);
       __ Move(dst, g.ToImmediate(source));
     } else if (destination->IsStackSlot()) {
       Operand dst = g.ToOperand(destination);
       __ Move(dst, g.ToImmediate(source));
     } else if (src_constant.type() == Constant::kFloat32) {
       // TODO(turbofan): Can we do better here?
       uint32_t src = bit_cast<uint32_t>(src_constant.ToFloat32());
       if (destination->IsDoubleRegister()) {
         XMMRegister dst = g.ToDoubleRegister(destination);
@@ skipping 44 matching lines @@
     UNREACHABLE();
   }
 }
 
 
 void CodeGenerator::AssembleSwap(InstructionOperand* source,
                                  InstructionOperand* destination) {
   IA32OperandConverter 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.
     Register src = g.ToRegister(source);
     Register dst = g.ToRegister(destination);
     __ xchg(dst, src);
-  } else if (source->IsRegister() && destination->IsStackSlot()) {
+  } else if (source->GeneratesRegister() && destination->IsStackSlot()) {
     // Register-memory.
     __ xchg(g.ToRegister(source), g.ToOperand(destination));
   } else if (source->IsStackSlot() && destination->IsStackSlot()) {
     // Memory-memory.
     Operand src = g.ToOperand(source);
     Operand dst = g.ToOperand(destination);
     __ push(dst);
     __ push(src);
     __ pop(dst);
     __ pop(src);
@@ skipping 51 matching lines @@
       __ Nop(padding_size);
     }
   }
 }
 
 #undef __
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8