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

src/compiler/instruction.h

 // 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.
 
 #ifndef V8_COMPILER_INSTRUCTION_H_
 #define V8_COMPILER_INSTRUCTION_H_
 
 #include <deque>
 #include <iosfwd>
 #include <map>
@@ skipping 12 matching lines @@
 namespace compiler {
 
 class Schedule;
 
 class InstructionOperand {
  public:
   static const int kInvalidVirtualRegister = -1;
 
   // TODO(dcarney): recover bit. INVALID can be represented as UNALLOCATED with
   // kInvalidVirtualRegister and some DCHECKS.
-  enum Kind { INVALID, UNALLOCATED, CONSTANT, IMMEDIATE, ALLOCATED };
+  enum Kind {
+    INVALID,
+    UNALLOCATED,
+    CONSTANT,
+    IMMEDIATE,
+    ALLOCATED,
+    STACK_POINTER,
+    FRAME_POINTER
+  };
 
   InstructionOperand() : InstructionOperand(INVALID) {}
 
   Kind kind() const { return KindField::decode(value_); }
 
 #define INSTRUCTION_OPERAND_PREDICATE(name, type) \
   bool Is##name() const { return kind() == type; }
   INSTRUCTION_OPERAND_PREDICATE(Invalid, INVALID)
   INSTRUCTION_OPERAND_PREDICATE(Unallocated, UNALLOCATED)
   INSTRUCTION_OPERAND_PREDICATE(Constant, CONSTANT)
   INSTRUCTION_OPERAND_PREDICATE(Immediate, IMMEDIATE)
   INSTRUCTION_OPERAND_PREDICATE(Allocated, ALLOCATED)
+  INSTRUCTION_OPERAND_PREDICATE(StackPointer, STACK_POINTER)
+  INSTRUCTION_OPERAND_PREDICATE(FramePointer, FRAME_POINTER)
 #undef INSTRUCTION_OPERAND_PREDICATE
 
   inline bool IsRegister() const;
   inline bool IsDoubleRegister() const;
   inline bool IsStackSlot() const;
   inline bool IsDoubleStackSlot() const;
 
+  inline bool GeneratesRegister() const {
+    return IsRegister() || IsStackPointer() || IsFramePointer();
+  }
+
   template <typename SubKindOperand>
   static SubKindOperand* New(Zone* zone, const SubKindOperand& op) {
     void* buffer = zone->New(sizeof(op));
     return new (buffer) SubKindOperand(op);
   }
 
   static void ReplaceWith(InstructionOperand* dest,
                           const InstructionOperand* src) {
     *dest = *src;
   }
@@ skipping 341 matching lines @@
 
   INSTRUCTION_OPERAND_CASTS(AllocatedOperand, ALLOCATED);
 
   STATIC_ASSERT(KindField::kSize == 3);
   class AllocatedKindField : public BitField64<AllocatedKind, 3, 2> {};
   class MachineTypeField : public BitField64<MachineType, 5, 16> {};
   class IndexField : public BitField64<int32_t, 35, 29> {};
 };
 
 
+class StackPointerOperand : public InstructionOperand {
+ public:
+  StackPointerOperand() : InstructionOperand(STACK_POINTER) {}
+
+  static StackPointerOperand* New(Zone* zone) {
+    return InstructionOperand::New(zone, StackPointerOperand());
+  }
+
+  INSTRUCTION_OPERAND_CASTS(StackPointerOperand, STACK_POINTER);
+};
+
+
+class FramePointerOperand : public InstructionOperand {
+ public:
+  FramePointerOperand() : InstructionOperand(FRAME_POINTER) {}
+
+  static FramePointerOperand* New(Zone* zone) {
+    return InstructionOperand::New(zone, FramePointerOperand());
+  }
+
+  INSTRUCTION_OPERAND_CASTS(FramePointerOperand, STACK_POINTER);
+};
+
+
 #undef INSTRUCTION_OPERAND_CASTS
 
 
 #define ALLOCATED_OPERAND_LIST(V)       \
   V(StackSlot, STACK_SLOT)              \
   V(DoubleStackSlot, DOUBLE_STACK_SLOT) \
   V(Register, REGISTER)                 \
   V(DoubleRegister, DOUBLE_REGISTER)
 
 
@@ skipping 779 matching lines @@
 
 
 std::ostream& operator<<(std::ostream& os,
                          const PrintableInstructionSequence& code);
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_INSTRUCTION_H_