[turbofan] Explicitly mark call sites as patchable.

src/compiler/js-generic-lowering.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/common-operator.h"
 #include "src/compiler/graph-inl.h"
 #include "src/compiler/js-generic-lowering.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node-aux-data-inl.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/unique.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 
 // TODO(mstarzinger): This is a temporary workaround for non-hydrogen stubs for
-// which we don't have an interface descriptor yet. Use ReplaceWithICStubCall
+// which we don't have an interface descriptor yet. Use ReplaceWithStubCall
 // once these stub have been made into a HydrogenCodeStub.
 template <typename T>
 static CodeStubInterfaceDescriptor* GetInterfaceDescriptor(Isolate* isolate,
                                                            T* stub) {
   CodeStub::Major key = static_cast<CodeStub*>(stub)->MajorKey();
   CodeStubInterfaceDescriptor* d = isolate->code_stub_interface_descriptor(key);
   stub->InitializeInterfaceDescriptor(d);
   return d;
 }
 
@@ skipping 180 matching lines @@
 #undef DECLARE_CASE
     default:
       // Nothing to see.
       return NoChange();
   }
   DCHECK_EQ(node, replacement);
   return Changed(replacement);
 }
 
 
-#define REPLACE_IC_STUB_CALL(op, StubDeclaration)  \
-  Node* JSGenericLowering::Lower##op(Node* node) { \
-    StubDeclaration;                               \
-    ReplaceWithICStubCall(node, &stub);            \
-    return node;                                   \
+#define REPLACE_BINARY_OP_IC_CALL(op, token)                                  \
+  Node* JSGenericLowering::Lower##op(Node* node) {                            \
+    BinaryOpICStub stub(isolate(), token);                                    \
+    ReplaceWithStubCall(node, &stub, CallDescriptor::kPatchableCallSite |     \

[Michael Starzinger, 2014/08/27 12:50:11]

nit: Can we use the kPatchableCallSiteWithNop shorthand here?

[Benedikt Meurer, 2014/08/28 11:46:57]

Done.

+                                         CallDescriptor::kNeedsNopAfterCall); \
+    return node;                                                              \
   }
-REPLACE_IC_STUB_CALL(JSBitwiseOr, BinaryOpICStub stub(isolate(), Token::BIT_OR))
-REPLACE_IC_STUB_CALL(JSBitwiseXor,
-                     BinaryOpICStub stub(isolate(), Token::BIT_XOR))
-REPLACE_IC_STUB_CALL(JSBitwiseAnd,
-                     BinaryOpICStub stub(isolate(), Token::BIT_AND))
-REPLACE_IC_STUB_CALL(JSShiftLeft, BinaryOpICStub stub(isolate(), Token::SHL))
-REPLACE_IC_STUB_CALL(JSShiftRight, BinaryOpICStub stub(isolate(), Token::SAR))
-REPLACE_IC_STUB_CALL(JSShiftRightLogical,
-                     BinaryOpICStub stub(isolate(), Token::SHR))
-REPLACE_IC_STUB_CALL(JSAdd, BinaryOpICStub stub(isolate(), Token::ADD))
-REPLACE_IC_STUB_CALL(JSSubtract, BinaryOpICStub stub(isolate(), Token::SUB))
-REPLACE_IC_STUB_CALL(JSMultiply, BinaryOpICStub stub(isolate(), Token::MUL))
-REPLACE_IC_STUB_CALL(JSDivide, BinaryOpICStub stub(isolate(), Token::DIV))
-REPLACE_IC_STUB_CALL(JSModulus, BinaryOpICStub stub(isolate(), Token::MOD))
-REPLACE_IC_STUB_CALL(JSToNumber, ToNumberStub stub(isolate()))
-#undef REPLACE_IC_STUB_CALL
+REPLACE_BINARY_OP_IC_CALL(JSBitwiseOr, Token::BIT_OR)
+REPLACE_BINARY_OP_IC_CALL(JSBitwiseXor, Token::BIT_XOR)
+REPLACE_BINARY_OP_IC_CALL(JSBitwiseAnd, Token::BIT_AND)
+REPLACE_BINARY_OP_IC_CALL(JSShiftLeft, Token::SHL)
+REPLACE_BINARY_OP_IC_CALL(JSShiftRight, Token::SAR)
+REPLACE_BINARY_OP_IC_CALL(JSShiftRightLogical, Token::SHR)
+REPLACE_BINARY_OP_IC_CALL(JSAdd, Token::ADD)
+REPLACE_BINARY_OP_IC_CALL(JSSubtract, Token::SUB)
+REPLACE_BINARY_OP_IC_CALL(JSMultiply, Token::MUL)
+REPLACE_BINARY_OP_IC_CALL(JSDivide, Token::DIV)
+REPLACE_BINARY_OP_IC_CALL(JSModulus, Token::MOD)
+#undef REPLACE_BINARY_OP_IC_CALL
+
+
+#define REPLACE_STUB_CALL(op, StubDeclaration)                  \
+  Node* JSGenericLowering::Lower##op(Node* node) {              \
+    StubDeclaration;                                            \
+    ReplaceWithStubCall(node, &stub, CallDescriptor::kNoFlags); \
+    return node;                                                \
+  }
+REPLACE_STUB_CALL(JSToNumber, ToNumberStub stub(isolate()))
+#undef REPLACE_STUB_CALL
 
 
 #define REPLACE_COMPARE_IC_CALL(op, token, pure)   \
   Node* JSGenericLowering::Lower##op(Node* node) { \
     ReplaceWithCompareIC(node, token, pure);       \
     return node;                                   \
   }
 REPLACE_COMPARE_IC_CALL(JSEqual, Token::EQ, false)
 REPLACE_COMPARE_IC_CALL(JSNotEqual, Token::NE, false)
 REPLACE_COMPARE_IC_CALL(JSStrictEqual, Token::EQ_STRICT, true)
@@ skipping 26 matching lines @@
     UNIMPLEMENTED();                               \
     return node;                                   \
   }
 REPLACE_UNIMPLEMENTED(JSToString)
 REPLACE_UNIMPLEMENTED(JSToName)
 REPLACE_UNIMPLEMENTED(JSYield)
 REPLACE_UNIMPLEMENTED(JSDebugger)
 #undef REPLACE_UNIMPLEMENTED
 
 
-static CallDescriptor::DeoptimizationSupport DeoptimizationSupportForNode(
-    Node* node) {
-  int result = CallDescriptor::kNoDeoptimization;
+static CallDescriptor::Flags FlagsForNode(Node* node) {
+  CallDescriptor::Flags result = CallDescriptor::kNoFlags;
   if (OperatorProperties::CanLazilyDeoptimize(node->op())) {
     result |= CallDescriptor::kLazyDeoptimization;
   }
   if (OperatorProperties::HasFrameStateInput(node->op())) {
     result |= CallDescriptor::kNeedsFrameState;
   }
-  return static_cast<CallDescriptor::DeoptimizationSupport>(result);
+  return result;
 }
 
 
 void JSGenericLowering::ReplaceWithCompareIC(Node* node, Token::Value token,
                                              bool pure) {
   BinaryOpICStub stub(isolate(), Token::ADD);  // TODO(mstarzinger): Hack.
   CodeStubInterfaceDescriptor* d = stub.GetInterfaceDescriptor();
-  CallDescriptor* desc_compare = linkage()->GetStubCallDescriptor(d);
+  CallDescriptor* desc_compare = linkage()->GetStubCallDescriptor(
+      d, 0, CallDescriptor::kPatchableCallSiteWithNop);
   Handle<Code> ic = CompareIC::GetUninitialized(isolate(), token);
   Node* compare;
   if (pure) {
     // A pure (strict) comparison doesn't have an effect or control.
     // But for the graph, we need to add these inputs.
     compare = graph()->NewNode(common()->Call(desc_compare), CodeConstant(ic),
                                NodeProperties::GetValueInput(node, 0),
                                NodeProperties::GetValueInput(node, 1),
                                NodeProperties::GetContextInput(node),
                                graph()->start(), graph()->start());
   } else {
     compare = graph()->NewNode(common()->Call(desc_compare), CodeConstant(ic),
                                NodeProperties::GetValueInput(node, 0),
                                NodeProperties::GetValueInput(node, 1),
                                NodeProperties::GetContextInput(node),
                                NodeProperties::GetEffectInput(node),
                                NodeProperties::GetControlInput(node));
   }
   node->ReplaceInput(0, compare);
   node->ReplaceInput(1, SmiConstant(token));
   ReplaceWithRuntimeCall(node, Runtime::kBooleanize);
 }
 
 
-void JSGenericLowering::ReplaceWithICStubCall(Node* node,
-                                              HydrogenCodeStub* stub) {
+void JSGenericLowering::ReplaceWithStubCall(Node* node, HydrogenCodeStub* stub,
+                                            CallDescriptor::Flags flags) {
   CodeStubInterfaceDescriptor* d = stub->GetInterfaceDescriptor();
-  CallDescriptor* desc = linkage()->GetStubCallDescriptor(
-      d, 0, DeoptimizationSupportForNode(node));
+  CallDescriptor* desc =
+      linkage()->GetStubCallDescriptor(d, 0, flags | FlagsForNode(node));
   Node* stub_code = CodeConstant(stub->GetCode());
   PatchInsertInput(node, 0, stub_code);
   PatchOperator(node, common()->Call(desc));
 }
 
 
 void JSGenericLowering::ReplaceWithBuiltinCall(Node* node,
                                                Builtins::JavaScript id,
                                                int nargs) {
   CallFunctionStub stub(isolate(), nargs - 1, NO_CALL_FUNCTION_FLAGS);
@@ skipping 10 matching lines @@
   PatchOperator(node, common()->Call(desc));
 }
 
 
 void JSGenericLowering::ReplaceWithRuntimeCall(Node* node,
                                                Runtime::FunctionId f,
                                                int nargs_override) {
   Operator::Property props = node->op()->properties();
   const Runtime::Function* fun = Runtime::FunctionForId(f);
   int nargs = (nargs_override < 0) ? fun->nargs : nargs_override;
-  CallDescriptor* desc = linkage()->GetRuntimeCallDescriptor(
-      f, nargs, props, DeoptimizationSupportForNode(node));
+  CallDescriptor* desc =
+      linkage()->GetRuntimeCallDescriptor(f, nargs, props, FlagsForNode(node));
   Node* ref = ExternalConstant(ExternalReference(f, isolate()));
   Node* arity = Int32Constant(nargs);
   if (!centrystub_constant_.is_set()) {
     centrystub_constant_.set(CodeConstant(CEntryStub(isolate(), 1).GetCode()));
   }
   PatchInsertInput(node, 0, centrystub_constant_.get());
   PatchInsertInput(node, nargs + 1, ref);
   PatchInsertInput(node, nargs + 2, arity);
   PatchOperator(node, common()->Call(desc));
 }
 
 
 Node* JSGenericLowering::LowerBranch(Node* node) {
   Node* test = graph()->NewNode(machine()->WordEqual(), node->InputAt(0),
                                 jsgraph()->TrueConstant());
   node->ReplaceInput(0, test);
   return node;
 }
 
 
 Node* JSGenericLowering::LowerJSUnaryNot(Node* node) {
   ToBooleanStub stub(isolate(), ToBooleanStub::RESULT_AS_INVERSE_ODDBALL);
-  ReplaceWithICStubCall(node, &stub);
+  ReplaceWithStubCall(node, &stub, CallDescriptor::kPatchableCallSite);
   return node;
 }
 
 
 Node* JSGenericLowering::LowerJSToBoolean(Node* node) {
   ToBooleanStub stub(isolate(), ToBooleanStub::RESULT_AS_ODDBALL);
-  ReplaceWithICStubCall(node, &stub);
+  ReplaceWithStubCall(node, &stub, CallDescriptor::kPatchableCallSite);
   return node;
 }
 
 
 Node* JSGenericLowering::LowerJSToObject(Node* node) {
   ReplaceWithBuiltinCall(node, Builtins::TO_OBJECT, 1);
   return node;
 }
 
 
 Node* JSGenericLowering::LowerJSLoadProperty(Node* node) {
   KeyedLoadICStubShim stub(isolate());
-  ReplaceWithICStubCall(node, &stub);
+  ReplaceWithStubCall(node, &stub, CallDescriptor::kPatchableCallSite);
   return node;
 }
 
 
 Node* JSGenericLowering::LowerJSLoadNamed(Node* node) {
   LoadNamedParameters p = OpParameter<LoadNamedParameters>(node);
   LoadICStubShim stub(isolate(), p.contextual_mode);
   PatchInsertInput(node, 1, jsgraph()->HeapConstant(p.name));
-  ReplaceWithICStubCall(node, &stub);
+  ReplaceWithStubCall(node, &stub, CallDescriptor::kPatchableCallSite);
   return node;
 }
 
 
 Node* JSGenericLowering::LowerJSStoreProperty(Node* node) {
   // TODO(mstarzinger): The strict_mode needs to be carried along in the
   // operator so that graphs are fully compositional for inlining.
   StrictMode strict_mode = info()->strict_mode();
   KeyedStoreICStubShim stub(isolate(), strict_mode);
-  ReplaceWithICStubCall(node, &stub);
+  ReplaceWithStubCall(node, &stub, CallDescriptor::kPatchableCallSite);
   return node;
 }
 
 
 Node* JSGenericLowering::LowerJSStoreNamed(Node* node) {
   PrintableUnique<Name> key = OpParameter<PrintableUnique<Name> >(node);
   // TODO(mstarzinger): The strict_mode needs to be carried along in the
   // operator so that graphs are fully compositional for inlining.
   StrictMode strict_mode = info()->strict_mode();
   StoreICStubShim stub(isolate(), strict_mode);
   PatchInsertInput(node, 1, jsgraph()->HeapConstant(key));
-  ReplaceWithICStubCall(node, &stub);
+  ReplaceWithStubCall(node, &stub, CallDescriptor::kPatchableCallSite);
   return node;
 }
 
 
 Node* JSGenericLowering::LowerJSDeleteProperty(Node* node) {
   StrictMode strict_mode = OpParameter<StrictMode>(node);
   PatchInsertInput(node, 2, SmiConstant(strict_mode));
   ReplaceWithBuiltinCall(node, Builtins::DELETE, 3);
   return node;
 }
@@ skipping 53 matching lines @@
   node->ReplaceInput(1, Int32Constant(Context::SlotOffset(access.index())));
   PatchOperator(node, machine()->Store(kMachAnyTagged, kFullWriteBarrier));
   return node;
 }
 
 
 Node* JSGenericLowering::LowerJSCallConstruct(Node* node) {
   int arity = OpParameter<int>(node);
   CallConstructStub stub(isolate(), NO_CALL_CONSTRUCTOR_FLAGS);
   CodeStubInterfaceDescriptor* d = GetInterfaceDescriptor(isolate(), &stub);
-  CallDescriptor* desc = linkage()->GetStubCallDescriptor(
-      d, arity, DeoptimizationSupportForNode(node));
+  CallDescriptor* desc =
+      linkage()->GetStubCallDescriptor(d, arity, FlagsForNode(node));
   Node* stub_code = CodeConstant(stub.GetCode());
   Node* construct = NodeProperties::GetValueInput(node, 0);
   PatchInsertInput(node, 0, stub_code);
   PatchInsertInput(node, 1, Int32Constant(arity - 1));
   PatchInsertInput(node, 2, construct);
   PatchInsertInput(node, 3, jsgraph()->UndefinedConstant());
   PatchOperator(node, common()->Call(desc));
   return node;
 }
 
 
 Node* JSGenericLowering::LowerJSCallFunction(Node* node) {
   CallParameters p = OpParameter<CallParameters>(node);
   CallFunctionStub stub(isolate(), p.arity - 2, p.flags);
   CodeStubInterfaceDescriptor* d = GetInterfaceDescriptor(isolate(), &stub);
-  CallDescriptor* desc = linkage()->GetStubCallDescriptor(
-      d, p.arity - 1, DeoptimizationSupportForNode(node));
+  CallDescriptor* desc =
+      linkage()->GetStubCallDescriptor(d, p.arity - 1, FlagsForNode(node));
   Node* stub_code = CodeConstant(stub.GetCode());
   PatchInsertInput(node, 0, stub_code);
   PatchOperator(node, common()->Call(desc));
   return node;
 }
 
 
 Node* JSGenericLowering::LowerJSCallRuntime(Node* node) {
   Runtime::FunctionId function = OpParameter<Runtime::FunctionId>(node);
   int arity = OperatorProperties::GetValueInputCount(node->op());
   ReplaceWithRuntimeCall(node, function, arity);
   return node;
 }
-}
-}
-}  // namespace v8::internal::compiler
+
+}  // namespace compiler
+}  // namespace internal
+}  // namespace v8