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

src/compiler/register-allocator.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/base/adapters.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/register-allocator.h"
 #include "src/string-stream.h"
 
 namespace v8 {
@@ skipping 148 matching lines @@
   UNREACHABLE();
   return false;
 }
 
 
 UsePositionHintType UsePosition::HintTypeForOperand(
     const InstructionOperand& op) {
   switch (op.kind()) {
     case InstructionOperand::CONSTANT:
     case InstructionOperand::IMMEDIATE:
+    case InstructionOperand::STACK_POINTER:
+    case InstructionOperand::FRAME_POINTER:
       return UsePositionHintType::kNone;
     case InstructionOperand::UNALLOCATED:
       return UsePositionHintType::kUnresolved;
     case InstructionOperand::ALLOCATED:
       switch (AllocatedOperand::cast(op).allocated_kind()) {
         case AllocatedOperand::REGISTER:
         case AllocatedOperand::DOUBLE_REGISTER:
           return UsePositionHintType::kOperand;
         case AllocatedOperand::STACK_SLOT:
         case AllocatedOperand::DOUBLE_STACK_SLOT:
@@ skipping 1059 matching lines @@
     }
   }
 }
 
 
 void ConstraintBuilder::MeetConstraintsBefore(int instr_index) {
   auto second = InstructionAt(instr_index);
   // Handle fixed input operands of second instruction.
   for (size_t i = 0; i < second->InputCount(); i++) {
     auto input = second->InputAt(i);
-    if (input->IsImmediate()) continue;  // Ignore immediates.
+    if (input->IsImmediate() || input->IsStackPointer() ||
+        input->IsFramePointer()) {
+      continue;  // Ignore immediates and special registers
+    }
     auto cur_input = UnallocatedOperand::cast(input);
     if (cur_input->HasFixedPolicy()) {
       int input_vreg = cur_input->virtual_register();
       UnallocatedOperand input_copy(UnallocatedOperand::ANY, input_vreg);
       bool is_tagged = IsReference(input_vreg);
       AllocateFixed(cur_input, instr_index, is_tagged);
       data()->AddGapMove(instr_index, Instruction::END, input_copy, *cur_input);
     }
   }
   // Handle "output same as input" for second instruction.
@@ skipping 252 matching lines @@
         if (!IsOutputDoubleRegisterOf(instr, i)) {
           auto range = FixedDoubleLiveRangeFor(i);
           range->AddUseInterval(curr_position, curr_position.End(),
                                 allocation_zone());
         }
       }
     }
 
     for (size_t i = 0; i < instr->InputCount(); i++) {
       auto input = instr->InputAt(i);
-      if (input->IsImmediate()) continue;  // Ignore immediates.
+      if (input->IsImmediate() || input->IsStackPointer() ||
+          input->IsFramePointer()) {
+        continue;  // Ignore immediates and special registers
+      }
       LifetimePosition use_pos;
       if (input->IsUnallocated() &&
           UnallocatedOperand::cast(input)->IsUsedAtStart()) {
         use_pos = curr_position;
       } else {
         use_pos = curr_position.End();
       }
 
       if (input->IsUnallocated()) {
         UnallocatedOperand* unalloc = UnallocatedOperand::cast(input);
@@ skipping 1352 matching lines @@
     auto eliminate = moves->PrepareInsertAfter(move);
     to_insert.push_back(move);
     if (eliminate != nullptr) to_eliminate.push_back(eliminate);
   }
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8