Towards removing dependency from generic lowering on compilation info.

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"
@@ skipping 137 matching lines @@
 
  private:
   virtual Major MajorKey() const V8_OVERRIDE { return NoCache; }
   virtual int NotMissMinorKey() const V8_OVERRIDE { return 0; }
   virtual bool UseSpecialCache() V8_OVERRIDE { return true; }
 
   StrictMode strict_mode_;
 };
 
 
-JSGenericLowering::JSGenericLowering(CompilationInfo* info, JSGraph* jsgraph,
+JSGenericLowering::JSGenericLowering(JSGraph* jsgraph,
+                                     JSContextSpecializer* spec,
+                                     Linkage* linkage,
                                      MachineOperatorBuilder* machine)
-    : info_(info),
-      jsgraph_(jsgraph),
-      linkage_(new (jsgraph->zone()) Linkage(info)),
-      machine_(machine) {}
+    : jsgraph_(jsgraph), spec_(spec), linkage_(linkage), machine_(machine) {}
 
 
 void JSGenericLowering::PatchOperator(Node* node, Operator* op) {
   node->set_op(op);
 }
 
 
 void JSGenericLowering::PatchInsertInput(Node* node, int index, Node* input) {
   node->InsertInput(zone(), index, input);
 }
@@ skipping 159 matching lines @@
   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);
-  // 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* function_node = spec_->InsertBuiltinLoadBefore(node, 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));
 }
 
 
 void JSGenericLowering::ReplaceWithRuntimeCall(Node* node,
                                                Runtime::FunctionId f,
                                                int nargs_override) {
   Operator::Property props = node->op()->properties();
@@ skipping 51 matching lines @@
 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);
   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();
+  StrictMode strict_mode = OpParameter<StrictMode>(node);
   KeyedStoreICStubShim stub(isolate(), strict_mode);
   ReplaceWithICStubCall(node, &stub);
   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));
+  StoreNamedParameters params = OpParameter<StoreNamedParameters>(node);
+  StoreICStubShim stub(isolate(), params.strict_mode);
+  PatchInsertInput(node, 1, jsgraph()->HeapConstant(params.name));
   ReplaceWithICStubCall(node, &stub);
   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 89 matching lines @@
 
 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