[turbofan] Unify referencing of stack slots

src/compiler/linkage.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/code-stubs.h"
 #include "src/compiler.h"
 #include "src/compiler/common-operator.h"
+#include "src/compiler/frame.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/node.h"
 #include "src/compiler/osr.h"
 #include "src/compiler/pipeline.h"
 #include "src/scopes.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
@@ skipping 165 matching lines @@
     SharedFunctionInfo* shared = info->closure()->shared();
     return GetJSCallDescriptor(zone, info->is_osr(),
                                1 + shared->internal_formal_parameter_count(),
                                CallDescriptor::kNoFlags);
   }
   return NULL;  // TODO(titzer): ?
 }
 
 
 FrameOffset Linkage::GetFrameOffset(int spill_slot, Frame* frame) const {
-  if (frame->GetSpillSlotCount() > 0 || incoming_->IsJSFunctionCall() ||
-      incoming_->kind() == CallDescriptor::kCallAddress) {
-    int offset;
-    int register_save_area_size = frame->GetRegisterSaveAreaSize();
-    if (spill_slot >= 0) {
-      // Local or spill slot. Skip the frame pointer, function, and
-      // context in the fixed part of the frame.
-      offset = -(spill_slot + 1) * kPointerSize - register_save_area_size;
-    } else {
-      // Incoming parameter. Skip the return address.
-      offset = -(spill_slot + 1) * kPointerSize + kFPOnStackSize +
-               frame->PCOnStackSize();
-    }
+  bool has_frame = frame->GetSpillSlotCount() > 0 ||
+                   incoming_->IsJSFunctionCall() ||
+                   incoming_->kind() == CallDescriptor::kCallAddress;
+  const int offset = (Frame::kFixedSlotCount - spill_slot - 1) * kPointerSize;
+  if (has_frame) {
     return FrameOffset::FromFramePointer(offset);
   } else {
     // No frame. Retrieve all parameters relative to stack pointer.
     DCHECK(spill_slot < 0);  // Must be a parameter.
-    int register_save_area_size = frame->GetRegisterSaveAreaSize();
-    int offset = register_save_area_size - (spill_slot + 1) * kPointerSize +
-                 frame->PCOnStackSize();
-    return FrameOffset::FromStackPointer(offset);
+    int offsetSpToFp = kPointerSize * (Frame::kFixedSlotCount -
+                                       frame->GetTotalFrameSlotCount());
+    return FrameOffset::FromStackPointer(offset - offsetSpToFp);
   }
 }
 
 
 // static
 int Linkage::FrameStateInputCount(Runtime::FunctionId function) {
   // Most runtime functions need a FrameState. A few chosen ones that we know
   // not to call into arbitrary JavaScript, not to throw, and not to deoptimize
   // are blacklisted here and can be called without a FrameState.
   switch (function) {
@@ skipping 266 matching lines @@
   int parameter_count = static_cast<int>(incoming_->JSParameterCount() - 1);
   int first_stack_slot = OsrHelper::FirstStackSlotIndex(parameter_count);
 
   if (index == kOsrContextSpillSlotIndex) {
     // Context. Use the parameter location of the context spill slot.
     // Parameter (arity + 1) is special for the context of the function frame.
     int context_index = 1 + 1 + parameter_count;  // target + receiver + params
     return incoming_->GetInputLocation(context_index);
   } else if (index >= first_stack_slot) {
     // Local variable stored in this (callee) stack.
-    int spill_index = index - first_stack_slot;
+    int spill_index = index - first_stack_slot + Frame::kJSFixedSlotCount;
     return LinkageLocation::ForCalleeFrameSlot(spill_index);
   } else {
     // Parameter. Use the assigned location from the incoming call descriptor.
     int parameter_index = 1 + index;  // skip index 0, which is the target.
     return incoming_->GetInputLocation(parameter_index);
   }
 }
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8