Implement lowering of JS[Load,Store][Property,Named] to ICs.

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 11 matching lines @@
 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);
+  }
+
+  virtual Handle<Code> GenerateCode() V8_OVERRIDE {
+    ExtraICState extra_state = LoadIC::ComputeExtraICState(contextual_mode_);
+    return LoadIC::initialize_stub(isolate(), extra_state);
+  }
+
+  virtual void InitializeInterfaceDescriptor(
+      CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE {
+    Register registers[] = { InterfaceDescriptor::ContextRegister(),
+                             LoadIC::ReceiverRegister(),
+                             LoadIC::NameRegister() };
+    descriptor->Initialize(MajorKey(), ARRAY_SIZE(registers), registers);
+  }
+
+ private:
+  virtual Major MajorKey() const V8_OVERRIDE { return NoCache; }
+  virtual int NotMissMinorKey() const V8_OVERRIDE { return 0; }
+  virtual bool UseSpecialCache() V8_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);
+  }
+
+  virtual Handle<Code> GenerateCode() V8_OVERRIDE {
+    return isolate()->builtins()->KeyedLoadIC_Initialize();
+  }
+
+  virtual void InitializeInterfaceDescriptor(
+      CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE {
+    Register registers[] = { InterfaceDescriptor::ContextRegister(),
+                             KeyedLoadIC::ReceiverRegister(),
+                             KeyedLoadIC::NameRegister() };
+    descriptor->Initialize(MajorKey(), ARRAY_SIZE(registers), registers);
+  }
+
+ private:
+  virtual Major MajorKey() const V8_OVERRIDE { return NoCache; }
+  virtual int NotMissMinorKey() const V8_OVERRIDE { return 0; }
+  virtual bool UseSpecialCache() V8_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);
+  }
+
+  virtual Handle<Code> GenerateCode() V8_OVERRIDE {
+    return StoreIC::initialize_stub(isolate(), strict_mode_);
+  }
+
+  virtual void InitializeInterfaceDescriptor(
+      CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE {
+    Register registers[] = { InterfaceDescriptor::ContextRegister(),
+                             StoreIC::ReceiverRegister(),
+                             StoreIC::NameRegister(),
+                             StoreIC::ValueRegister() };
+    descriptor->Initialize(MajorKey(), ARRAY_SIZE(registers), registers);
+  }
+
+ 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_;
+};
+
+
+// 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);
+  }
+
+  virtual Handle<Code> GenerateCode() V8_OVERRIDE {
+    return strict_mode_ == SLOPPY
+               ? isolate()->builtins()->KeyedStoreIC_Initialize()
+               : isolate()->builtins()->KeyedStoreIC_Initialize_Strict();
+  }
+
+  virtual void InitializeInterfaceDescriptor(
+      CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE {
+    Register registers[] = { InterfaceDescriptor::ContextRegister(),
+                             KeyedStoreIC::ReceiverRegister(),
+                             KeyedStoreIC::NameRegister(),
+                             KeyedStoreIC::ValueRegister() };
+    descriptor->Initialize(MajorKey(), ARRAY_SIZE(registers), registers);
+  }
+
+ 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,
                                      MachineOperatorBuilder* machine,
                                      SourcePositionTable* source_positions)
     : LoweringBuilder(jsgraph->graph(), source_positions),
       info_(info),
       jsgraph_(jsgraph),
       linkage_(new (jsgraph->zone()) Linkage(info)),
       machine_(machine) {}
 
 
@@ skipping 247 matching lines @@
 }
 
 
 Node* JSGenericLowering::LowerJSToObject(Node* node) {
   ReplaceWithBuiltinCall(node, Builtins::TO_OBJECT, 1);
   return node;
 }
 
 
 Node* JSGenericLowering::LowerJSLoadProperty(Node* node) {
-  if (FLAG_compiled_keyed_generic_loads) {
-    KeyedLoadGenericStub stub(isolate());
-    ReplaceWithICStubCall(node, &stub);
-  } else {
-    ReplaceWithRuntimeCall(node, Runtime::kKeyedGetProperty);
-  }
+  KeyedLoadICStubShim stub(isolate());

[titzer, 2014/08/05 12:33:27]

Do we still want to respect the flag?

[Michael Starzinger, 2014/08/05 12:41:38]

I don't think so. I only added the check because this flag also changes the
encoding in the lookup cache. The flag is still respected implicitly in
KeyedLoadIC::generic_stub when the KeyedLoadIC we are using decides to go
generic.

+  ReplaceWithICStubCall(node, &stub);
   return node;
 }
 
 
 Node* JSGenericLowering::LowerJSLoadNamed(Node* node) {
-  Node* key =
-      jsgraph()->HeapConstant(OpParameter<PrintableUnique<Name> >(node));
-  PatchInsertInput(node, 1, key);
-  // TODO(mstarzinger): We cannot yet use KeyedLoadGenericElementStub here,
-  // because named interceptors would not fire correctly yet.
-  ReplaceWithRuntimeCall(node, Runtime::kGetProperty);
+  PrintableUnique<Name> key = OpParameter<PrintableUnique<Name> >(node);
+  // TODO(mstarzinger): The ContextualMode needs to be carried along in the
+  // operator to use JSLoadNamed for global variable loads.
+  LoadICStubShim stub(isolate(), NOT_CONTEXTUAL);
+  PatchInsertInput(node, 1, jsgraph()->HeapConstant(key));
+  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();
-  PatchInsertInput(node, 3, SmiConstant(strict_mode));
-  ReplaceWithRuntimeCall(node, Runtime::kSetProperty, 4);
+  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();
-  Node* key =
-      jsgraph()->HeapConstant(OpParameter<PrintableUnique<Name> >(node));
-  PatchInsertInput(node, 1, key);
-  PatchInsertInput(node, 3, SmiConstant(strict_mode));
-  ReplaceWithRuntimeCall(node, Runtime::kSetProperty, 4);
+  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);
   return node;
 }
@@ skipping 86 matching lines @@
 
 Node* JSGenericLowering::LowerJSCallRuntime(Node* node) {
   Runtime::FunctionId function = OpParameter<Runtime::FunctionId>(node);
   int arity = NodeProperties::GetValueInputCount(node);
   ReplaceWithRuntimeCall(node, function, arity);
   return node;
 }
 }
 }
 }  // namespace v8::internal::compiler