[runtime] Unify and simplify how frames are marked

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/ast/scopes.h"
 #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"
@@ skipping 301 matching lines @@
   types.AddParam(MachineType::Int32());
 
   // Add context.
   locations.AddParam(regloc(kContextRegister));
   types.AddParam(MachineType::AnyTagged());
 
   // The target for JS function calls is the JSFunction object.
   MachineType target_type = MachineType::AnyTagged();
   // When entering into an OSR function from unoptimized code the JSFunction
   // is not in a register, but it is on the stack in the marker spill slot.
-  LinkageLocation target_loc = is_osr ? LinkageLocation::ForSavedCallerMarker()
-                                      : regloc(kJSFunctionRegister);
-  return new (zone) CallDescriptor(     // --
-      CallDescriptor::kCallJSFunction,  // kind
-      target_type,                      // target MachineType
-      target_loc,                       // target location
-      types.Build(),                    // machine_sig
-      locations.Build(),                // location_sig
-      js_parameter_count,               // stack_parameter_count
-      Operator::kNoProperties,          // properties
-      kNoCalleeSaved,                   // callee-saved
-      kNoCalleeSaved,                   // callee-saved fp
-      CallDescriptor::kCanUseRoots |    // flags
-          flags,                        // flags
+  LinkageLocation target_loc = is_osr
+                                   ? LinkageLocation::ForSavedCallerFunction()
+                                   : regloc(kJSFunctionRegister);
+  return new (zone) CallDescriptor(                  // --
+      CallDescriptor::kCallJSFunction,               // kind
+      target_type,                                   // target MachineType
+      target_loc,                                    // target location
+      types.Build(),                                 // machine_sig
+      locations.Build(),                             // location_sig
+      js_parameter_count,                            // stack_parameter_count
+      Operator::kNoProperties,                       // properties
+      kNoCalleeSaved,                                // callee-saved
+      kNoCalleeSaved,                                // callee-saved fp
+      CallDescriptor::kCanUseRoots |                 // flags
+          CallDescriptor::kHasStandardFrameHeader |  // flags
+          flags,                                     // flags
       "js-call");
 }
 
 // TODO(all): Add support for return representations/locations to
 // CallInterfaceDescriptor.
 // TODO(turbofan): cache call descriptors for code stub calls.
 CallDescriptor* Linkage::GetStubCallDescriptor(
     Isolate* isolate, Zone* zone, const CallInterfaceDescriptor& descriptor,
     int stack_parameter_count, CallDescriptor::Flags flags,
     Operator::Properties properties, MachineType return_type,
@@ skipping 78 matching lines @@
     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);
   }
 }
 
 
 bool Linkage::ParameterHasSecondaryLocation(int index) const {
+  if ((incoming_->flags() & CallDescriptor::kHasStandardFrameHeader) == 0) {

[Benedikt Meurer, 2016/02/22 18:16:38]

Nit: For "flags" I'd prefer to not use explicit comparison against 0 to
distinguish them easily from integer bitmasking.

[danno, 2016/03/07 09:33:38]

Done.

+    return false;
+  }
   if (incoming_->kind() != CallDescriptor::kCallJSFunction) return false;
   LinkageLocation loc = GetParameterLocation(index);
   return (loc == regloc(kJSFunctionRegister) ||
           loc == regloc(kContextRegister));
 }
 
 LinkageLocation Linkage::GetParameterSecondaryLocation(int index) const {
   DCHECK(ParameterHasSecondaryLocation(index));
   LinkageLocation loc = GetParameterLocation(index);
 
   if (loc == regloc(kJSFunctionRegister)) {
     return LinkageLocation::ForCalleeFrameSlot(Frame::kJSFunctionSlot);
   } else {
     DCHECK(loc == regloc(kContextRegister));
     return LinkageLocation::ForCalleeFrameSlot(Frame::kContextSlot);
   }
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8