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

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

 // Copyright 2014 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/arm/macro-assembler-arm.h"
 #include "src/compiler/code-generator-impl.h"
 #include "src/compiler/gap-resolver.h"
 #include "src/compiler/node-matchers.h"
@@ skipping 129 matching lines @@
     UNREACHABLE();
     return MemOperand(r0);
   }
 
   MemOperand InputOffset(size_t first_index = 0) {
     return InputOffset(&first_index);
   }
 
   MemOperand ToMemOperand(InstructionOperand* op) const {
     DCHECK(op != NULL);
-    DCHECK(!op->IsRegister());
+    DCHECK(!op->GeneratesRegister());
     DCHECK(!op->IsDoubleRegister());
     DCHECK(op->IsStackSlot() || op->IsDoubleStackSlot());
     // The linkage computes where all spill slots are located.
     FrameOffset offset = linkage()->GetFrameOffset(
         AllocatedOperand::cast(op)->index(), frame(), 0);
     return MemOperand(offset.from_stack_pointer() ? sp : fp, offset.offset());
   }
 };
 
 
@@ skipping 73 matching lines @@
   return kNoCondition;
 }
 
 }  // namespace
 
 
 #define ASSEMBLE_CHECKED_LOAD_FLOAT(width)                           \
   do {                                                               \
     auto result = i.OutputFloat##width##Register();                  \
     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));                           \
     }                                                                \
     auto ool = new (zone()) OutOfLineLoadFloat##width(this, result); \
     __ b(hs, ool->entry());                                          \
     __ vldr(result, i.InputOffset(2));                               \
     __ bind(ool->exit());                                            \
     DCHECK_EQ(LeaveCC, i.OutputSBit());                              \
   } while (0)
 
 
 #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));                      \
     }                                                           \
     auto ool = new (zone()) OutOfLineLoadInteger(this, result); \
     __ b(hs, ool->entry());                                     \
     __ asm_instr(result, i.InputOffset(2));                     \
     __ bind(ool->exit());                                       \
     DCHECK_EQ(LeaveCC, i.OutputSBit());                         \
   } while (0)
 
 
 #define ASSEMBLE_CHECKED_STORE_FLOAT(width)        \
   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));         \
     }                                              \
     auto value = i.InputFloat##width##Register(2); \
     __ vstr(value, i.InputOffset(3), lo);          \
     DCHECK_EQ(LeaveCC, i.OutputSBit());            \
   } while (0)
 
 
 #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));        \
     }                                             \
     auto value = i.InputRegister(2);              \
     __ asm_instr(value, i.InputOffset(3), lo);    \
     DCHECK_EQ(LeaveCC, i.OutputSBit());           \
   } while (0)
 
 
@@ skipping 761 matching lines @@
     __ Ret();
   }
 }
 
 
 void CodeGenerator::AssembleMove(InstructionOperand* source,
                                  InstructionOperand* destination) {
   ArmOperandConverter 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()) {
       __ mov(g.ToRegister(destination), src);
     } else {
       __ str(src, g.ToMemOperand(destination));
     }
   } else if (source->IsStackSlot()) {
-    DCHECK(destination->IsRegister() || destination->IsStackSlot());
+    DCHECK(destination->GeneratesRegister() || destination->IsStackSlot());
     MemOperand src = g.ToMemOperand(source);
-    if (destination->IsRegister()) {
+    if (destination->GeneratesRegister()) {
       __ ldr(g.ToRegister(destination), src);
     } else {
       Register temp = kScratchReg;
       __ ldr(temp, src);
       __ str(temp, g.ToMemOperand(destination));
     }
   } else if (source->IsConstant()) {
     Constant src = g.ToConstant(source);
-    if (destination->IsRegister() || destination->IsStackSlot()) {
-      Register dst =
-          destination->IsRegister() ? g.ToRegister(destination) : kScratchReg;
+    if (destination->GeneratesRegister() || destination->IsStackSlot()) {
+      Register dst = destination->GeneratesRegister()
+                         ? g.ToRegister(destination)
+                         : kScratchReg;
       switch (src.type()) {
         case Constant::kInt32:
           __ mov(dst, Operand(src.ToInt32()));
           break;
         case Constant::kInt64:
           UNREACHABLE();
           break;
         case Constant::kFloat32:
           __ Move(dst,
                   isolate()->factory()->NewNumber(src.ToFloat32(), TENURED));
@@ skipping 65 matching lines @@
     UNREACHABLE();
   }
 }
 
 
 void CodeGenerator::AssembleSwap(InstructionOperand* source,
                                  InstructionOperand* destination) {
   ArmOperandConverter g(this, NULL);
   // Dispatch on the source and destination operand kinds.  Not all
   // combinations are possible.
-  if (source->IsRegister()) {
+  if (source->GeneratesRegister()) {
     // Register-register.
     Register temp = kScratchReg;
     Register src = g.ToRegister(source);
-    if (destination->IsRegister()) {
+    if (destination->GeneratesRegister()) {
       Register dst = g.ToRegister(destination);
       __ Move(temp, src);
       __ Move(src, dst);
       __ Move(dst, temp);
     } else {
       DCHECK(destination->IsStackSlot());
       MemOperand dst = g.ToMemOperand(destination);
       __ mov(temp, src);
       __ ldr(src, dst);
       __ str(temp, dst);
@@ skipping 72 matching lines @@
       }
     }
   }
 }
 
 #undef __
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8