Make AST graph builder parametric in context specialization.

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 321 matching lines @@
                                               HydrogenCodeStub* stub) {
   CodeStubInterfaceDescriptor* d = stub->GetInterfaceDescriptor();
   CallDescriptor* desc = linkage()->GetStubCallDescriptor(
       d, 0, DeoptimizationSupportForNode(node));
   Node* stub_code = CodeConstant(stub->GetCode());
   PatchInsertInput(node, 0, stub_code);
   PatchOperator(node, common()->Call(desc));
 }
 
 
+Node* JSGenericLowering::LoadObjectField(Node* object, int offset,
+                                         Node* effect) {
+  MachineOperatorBuilder machine(jsgraph()->zone());
+  Node* field_load = jsgraph()->graph()->NewNode(
+      machine.Load(kMachAnyTagged), object,
+      jsgraph()->Int32Constant(offset - kHeapObjectTag), effect);
+  return field_load;
+}
+
+
 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* stub_code = CodeConstant(stub.GetCode());
-  Node* function_node = FunctionConstant(function);
+  Node* function_node = NULL;
+  if (info()->is_context_specializing()) {
+    Handle<JSFunction> function(JSFunction::cast(
+        info()->context()->builtins()->javascript_builtin(id)));
+    function_node = FunctionConstant(function);
+  } else {
+    Node* context = NodeProperties::GetContextInput(node);
+    Node* effect = NodeProperties::GetEffectInput(node);
+    Node* global = LoadObjectField(
+        context,
+        Context::SlotOffset(Context::GLOBAL_OBJECT_INDEX) + kHeapObjectTag,
+        effect);
+    Node* builtins =
+        LoadObjectField(global, JSGlobalObject::kBuiltinsOffset, effect);
+    function_node = LoadObjectField(
+        builtins, JSBuiltinsObject::OffsetOfFunctionWithId(id), effect);
+    NodeProperties::ReplaceEffectInput(node, function_node);
+  }
   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 74 matching lines @@
   StrictMode strict_mode = info()->strict_mode();
   StoreICStubShim stub(isolate(), strict_mode);
   PatchInsertInput(node, 1, jsgraph()->HeapConstant(key));
   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);
+  PatchInsertInput(node, 4, SmiConstant(strict_mode));
   return node;
 }
 
 
 Node* JSGenericLowering::LowerJSHasProperty(Node* node) {
   ReplaceWithBuiltinCall(node, Builtins::IN, 2);
   return node;
 }
 
 
@@ skipping 80 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