[turbofan] Add general support for sp-based frame access

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/frame-access-state.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 121 matching lines @@
     // plus the receiver.
     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 {
-  bool has_frame = frame->GetSpillSlotCount() > 0 ||
-                   incoming_->IsJSFunctionCall() ||
-                   incoming_->kind() == CallDescriptor::kCallAddress;
+FrameOffset Linkage::GetFrameOffset(

[titzer, 2015/11/23 20:00:54]

Now that I think about this method in modern times, it strikes me that it's a
little misplaced. It doesn't seem to access anything from the linkage itself, so
maybe it should be moved?

[danno, 2015/11/24 12:02:00]

Done.

+    int spill_slot, FrameAccessState* frame_access_state) const {
   const int offset =
       (StandardFrameConstants::kFixedSlotCountAboveFp - spill_slot - 1) *
       kPointerSize;
-  if (has_frame) {
+  if (frame_access_state->access_frame_with_fp()) {
+    DCHECK(frame_access_state->frame()->needs_frame());
     return FrameOffset::FromFramePointer(offset);
   } else {
     // No frame. Retrieve all parameters relative to stack pointer.
-    DCHECK(spill_slot < 0);  // Must be a parameter.
-    int sp_offset = offset + (frame->GetSpToFpSlotCount() * kPointerSize);
+    int sp_offset =
+        offset + ((frame_access_state->frame()->GetSpToFpSlotCount() +
+                   frame_access_state->sp_delta()) *
+                  kPointerSize);
     return FrameOffset::FromStackPointer(sp_offset);
   }
 }
 
 
 // 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.
@@ skipping 369 matching lines @@
   } else {
     DCHECK(loc == regloc(kContextRegister));
     return LinkageLocation::ForCalleeFrameSlot(Frame::kContextSlot);
   }
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8