Initial shot at deoptimizing JSCallFunction in Turbofan.

src/compiler/js-operator.h

 // Copyright 2013 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_JS_OPERATOR_H_
 #define V8_COMPILER_JS_OPERATOR_H_
 
+#include "src/compiler/linkage.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 #include "src/unique.h"
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 // Defines the location of a context slot relative to a specific scope. This is
@@ skipping 23 matching lines @@
 struct LoadNamedParameters {
   PrintableUnique<Name> name;
   ContextualMode contextual_mode;
 };
 
 // Defines the arity and the call flags for a JavaScript function call. This is
 // used as a parameter by JSCall operators.
 struct CallParameters {
   int arity;
   CallFunctionFlags flags;
+  // TODO(jarin) Remove the deopt flag once we can deoptimize all JavaScript
+  // calls (specifically the FILTER_KEY call in ForInStatement).
+  CallDescriptor::DeoptimizationSupport can_deoptimize;
 };
 
 // Interface for building JavaScript-level operators, e.g. directly from the
 // AST. Most operators have no parameters, thus can be globally shared for all
 // graphs.
 class JSOperatorBuilder {
  public:
   explicit JSOperatorBuilder(Zone* zone) : zone_(zone) {}
 
 #define SIMPLE(name, properties, inputs, outputs) \
@@ skipping 35 matching lines @@
   Operator* UnaryNot() { UNOP(JSUnaryNot); }
   Operator* ToBoolean() { UNOP(JSToBoolean); }
   Operator* ToNumber() { UNOP(JSToNumber); }
   Operator* ToString() { UNOP(JSToString); }
   Operator* ToName() { UNOP(JSToName); }
   Operator* ToObject() { UNOP(JSToObject); }
   Operator* Yield() { UNOP(JSYield); }
 
   Operator* Create() { SIMPLE(JSCreate, Operator::kEliminatable, 0, 1); }
 
-  Operator* Call(int arguments, CallFunctionFlags flags) {
-    CallParameters parameters = {arguments, flags};
+  Operator* Call(int arguments, CallFunctionFlags flags,
+                 CallDescriptor::DeoptimizationSupport can_deoptimize) {
+    CallParameters parameters = {arguments, flags, can_deoptimize};
     OP1(JSCallFunction, CallParameters, parameters, Operator::kNoProperties,
         arguments, 1);
   }
 
   Operator* CallNew(int arguments) {
     return new (zone_)
         Operator1<int>(IrOpcode::kJSCallConstruct, Operator::kNoProperties,
                        arguments, 1, "JSCallConstruct", arguments);
   }
 
@@ skipping 86 matching lines @@
   static int HashCode(Runtime::FunctionId val) { return static_cast<int>(val); }
   static bool Equals(Runtime::FunctionId a, Runtime::FunctionId b) {
     return a == b;
   }
 };
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_JS_OPERATOR_H_