Do not cache CodeStubInterfaceDescriptor on the isolate.

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 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;
-}
-
-
 // TODO(mstarzinger): This is a temporary shim to be able to call an IC stub
 // which doesn't have an interface descriptor yet. It mimics a hydrogen code
 // stub for the underlying IC stub code.
 class LoadICStubShim : public HydrogenCodeStub {
  public:
   LoadICStubShim(Isolate* isolate, ContextualMode contextual_mode)
-      : HydrogenCodeStub(isolate), contextual_mode_(contextual_mode) {
-    i::compiler::GetInterfaceDescriptor(isolate, this);
-  }
+      : HydrogenCodeStub(isolate), contextual_mode_(contextual_mode) {}
 
   virtual Handle<Code> GenerateCode() OVERRIDE {
     ExtraICState extra_state = LoadIC::ComputeExtraICState(contextual_mode_);
     return LoadIC::initialize_stub(isolate(), extra_state);
   }
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE {
     LoadDescriptor call_descriptor(isolate());
     descriptor->Initialize(MajorKey(), call_descriptor);
   }
 
  private:
   virtual Major MajorKey() const OVERRIDE { return NoCache; }
   virtual bool UseSpecialCache() OVERRIDE { return true; }
 
   ContextualMode contextual_mode_;
 };
 
 
 // TODO(mstarzinger): This is a temporary shim to be able to call an IC stub
 // which doesn't have an interface descriptor yet. It mimics a hydrogen code
 // stub for the underlying IC stub code.
 class KeyedLoadICStubShim : public HydrogenCodeStub {
  public:
-  explicit KeyedLoadICStubShim(Isolate* isolate) : HydrogenCodeStub(isolate) {
-    i::compiler::GetInterfaceDescriptor(isolate, this);
-  }
+  explicit KeyedLoadICStubShim(Isolate* isolate) : HydrogenCodeStub(isolate) {}
 
   virtual Handle<Code> GenerateCode() OVERRIDE {
     return isolate()->builtins()->KeyedLoadIC_Initialize();
   }
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE {
     LoadDescriptor call_descriptor(isolate());
     descriptor->Initialize(MajorKey(), call_descriptor);
   }
 
  private:
   virtual Major MajorKey() const OVERRIDE { return NoCache; }
   virtual bool UseSpecialCache() OVERRIDE { return true; }
 };
 
 
 // TODO(mstarzinger): This is a temporary shim to be able to call an IC stub
 // which doesn't have an interface descriptor yet. It mimics a hydrogen code
 // stub for the underlying IC stub code.
 class StoreICStubShim : public HydrogenCodeStub {
  public:
   StoreICStubShim(Isolate* isolate, StrictMode strict_mode)
-      : HydrogenCodeStub(isolate), strict_mode_(strict_mode) {
-    i::compiler::GetInterfaceDescriptor(isolate, this);
-  }
+      : HydrogenCodeStub(isolate), strict_mode_(strict_mode) {}
 
   virtual Handle<Code> GenerateCode() OVERRIDE {
     return StoreIC::initialize_stub(isolate(), strict_mode_);
   }
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE {
     StoreDescriptor call_descriptor(isolate());
     descriptor->Initialize(MajorKey(), call_descriptor);
   }
 
  private:
   virtual Major MajorKey() const OVERRIDE { return NoCache; }
   virtual bool UseSpecialCache() OVERRIDE { return true; }
 
   StrictMode strict_mode_;
 };
 
 
 // TODO(mstarzinger): This is a temporary shim to be able to call an IC stub
 // which doesn't have an interface descriptor yet. It mimics a hydrogen code
 // stub for the underlying IC stub code.
 class KeyedStoreICStubShim : public HydrogenCodeStub {
  public:
   KeyedStoreICStubShim(Isolate* isolate, StrictMode strict_mode)
-      : HydrogenCodeStub(isolate), strict_mode_(strict_mode) {
-    i::compiler::GetInterfaceDescriptor(isolate, this);
-  }
+      : HydrogenCodeStub(isolate), strict_mode_(strict_mode) {}
 
   virtual Handle<Code> GenerateCode() OVERRIDE {
     return strict_mode_ == SLOPPY
                ? isolate()->builtins()->KeyedStoreIC_Initialize()
                : isolate()->builtins()->KeyedStoreIC_Initialize_Strict();
   }
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE {
     StoreDescriptor call_descriptor(isolate());
@@ skipping 150 matching lines @@
   if (OperatorProperties::HasFrameStateInput(node->op())) {
     result |= CallDescriptor::kNeedsFrameState;
   }
   return result;
 }
 
 
 void JSGenericLowering::ReplaceWithCompareIC(Node* node, Token::Value token,
                                              bool pure) {
   BinaryOpICStub stub(isolate(), Token::ADD);  // TODO(mstarzinger): Hack.
-  CodeStubInterfaceDescriptor* d = stub.GetInterfaceDescriptor();
+  CodeStubInterfaceDescriptor d;
+  stub.InitializeInterfaceDescriptor(&d);
   bool has_frame_state = OperatorProperties::HasFrameStateInput(node->op());
   CallDescriptor* desc_compare = linkage()->GetStubCallDescriptor(
-      d, 0, CallDescriptor::kPatchableCallSiteWithNop | FlagsForNode(node));
+      &d, 0, CallDescriptor::kPatchableCallSiteWithNop | FlagsForNode(node));
   Handle<Code> ic = CompareIC::GetUninitialized(isolate(), token);
   NodeVector inputs(zone());
   inputs.reserve(node->InputCount() + 1);
   inputs.push_back(CodeConstant(ic));
   inputs.push_back(NodeProperties::GetValueInput(node, 0));
   inputs.push_back(NodeProperties::GetValueInput(node, 1));
   inputs.push_back(NodeProperties::GetContextInput(node));
   if (pure) {
     // A pure (strict) comparison doesn't have an effect, control or frame
     // state.  But for the graph, we need to add control and effect inputs.
@@ skipping 26 matching lines @@
     }
     node->TrimInputCount(dest);
   }
 
   ReplaceWithRuntimeCall(node, Runtime::kBooleanize);
 }
 
 
 void JSGenericLowering::ReplaceWithStubCall(Node* node, HydrogenCodeStub* stub,
                                             CallDescriptor::Flags flags) {
-  CodeStubInterfaceDescriptor* d = stub->GetInterfaceDescriptor();
+  CodeStubInterfaceDescriptor d;
+  stub->InitializeInterfaceDescriptor(&d);
   CallDescriptor* desc =
-      linkage()->GetStubCallDescriptor(d, 0, flags | FlagsForNode(node));
+      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);
-  CodeStubInterfaceDescriptor* d = GetInterfaceDescriptor(isolate(), &stub);
-  CallDescriptor* desc = linkage()->GetStubCallDescriptor(d, nargs);
+  CodeStubInterfaceDescriptor d;
+  stub.InitializeInterfaceDescriptor(&d);
+  CallDescriptor* desc = linkage()->GetStubCallDescriptor(&d, nargs);
   // TODO(mstarzinger): Accessing the builtins object this way prevents sharing
   // of code across native contexts. Fix this by loading from given context.
   Handle<JSFunction> function(
       JSFunction::cast(info()->context()->builtins()->javascript_builtin(id)));
   Node* stub_code = CodeConstant(stub.GetCode());
   Node* function_node = FunctionConstant(function);
   PatchInsertInput(node, 0, stub_code);
   PatchInsertInput(node, 1, function_node);
   PatchOperator(node, common()->Call(desc));
 }
@@ skipping 103 matching lines @@
   ReplaceWithBuiltinCall(node, Builtins::IN, 2);
   return node;
 }
 
 
 Node* JSGenericLowering::LowerJSInstanceOf(Node* node) {
   InstanceofStub::Flags flags = static_cast<InstanceofStub::Flags>(
       InstanceofStub::kReturnTrueFalseObject |
       InstanceofStub::kArgsInRegisters);
   InstanceofStub stub(isolate(), flags);
-  CodeStubInterfaceDescriptor* d = GetInterfaceDescriptor(isolate(), &stub);
-  CallDescriptor* desc = linkage()->GetStubCallDescriptor(d, 0);
+  CodeStubInterfaceDescriptor d;
+  stub.InitializeInterfaceDescriptor(&d);
+  CallDescriptor* desc = linkage()->GetStubCallDescriptor(&d, 0);
   Node* stub_code = CodeConstant(stub.GetCode());
   PatchInsertInput(node, 0, stub_code);
   PatchOperator(node, common()->Call(desc));
   return node;
 }
 
 
 Node* JSGenericLowering::LowerJSLoadContext(Node* node) {
   ContextAccess access = OpParameter<ContextAccess>(node);
   // TODO(mstarzinger): Use simplified operators instead of machine operators
@@ skipping 27 matching lines @@
   node->ReplaceInput(2, NodeProperties::GetValueInput(node, 1));
   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);
+  CodeStubInterfaceDescriptor d;
+  stub.InitializeInterfaceDescriptor(&d);
   CallDescriptor* desc =
-      linkage()->GetStubCallDescriptor(d, arity, FlagsForNode(node));
+      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);
+  CodeStubInterfaceDescriptor d;
+  stub.InitializeInterfaceDescriptor(&d);
   CallDescriptor* desc =
-      linkage()->GetStubCallDescriptor(d, p.arity - 1, FlagsForNode(node));
+      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 compiler
 }  // namespace internal
 }  // namespace v8