[builtins] Turn LoadIC_Miss and LoadIC_Slow builtins to TurboFan code stubs.

src/code-stubs.h

 // Copyright 2012 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.
 
 #ifndef V8_CODE_STUBS_H_
 #define V8_CODE_STUBS_H_
 
 #include "src/allocation.h"
 #include "src/assembler.h"
 #include "src/code-stub-assembler.h"
@@ skipping 131 matching lines @@
   V(LoadICTrampolineTF)                     \
   V(LoadICTF)                               \
   /* IC Handler stubs */                    \
   V(ArrayBufferViewLoadField)               \
   V(KeyedLoadSloppyArguments)               \
   V(KeyedStoreSloppyArguments)              \
   V(LoadApiGetter)                          \
   V(LoadConstant)                           \
   V(LoadFastElement)                        \
   V(LoadField)                              \
+  V(LoadICMiss)                             \
+  V(LoadICSlow)                             \
   V(LoadIndexedInterceptor)                 \
   V(StoreField)                             \
   V(StoreGlobal)                            \
   V(StoreInterceptor)                       \
   V(StoreTransition)
 
 // List of code stubs only used on ARM 32 bits platforms.
 #if V8_TARGET_ARCH_ARM
 #define CODE_STUB_LIST_ARM(V) V(DirectCEntry)
 
@@ skipping 235 matching lines @@
  public:                                                              \
   void InitializeDescriptor(CodeStubDescriptor* descriptor) override; \
   Handle<Code> GenerateCode() override;                               \
   DEFINE_CODE_STUB(NAME, SUPER)
 
 #define DEFINE_TURBOFAN_CODE_STUB(NAME, SUPER)                        \
  public:                                                              \
   void GenerateAssembly(CodeStubAssembler* assembler) const override; \
   DEFINE_CODE_STUB(NAME, SUPER)
 
+#define DEFINE_TURBOFAN_HANDLER_CODE_STUB(NAME, EXTRA_IC_STATE)            \
+ public:                                                                   \
+  Code::Kind GetCodeKind() const override { return Code::HANDLER; }        \
+  ExtraICState GetExtraICState() const override { return EXTRA_IC_STATE; } \

[Toon Verwaest, 2016/06/06 13:01:32]

EXTRA_IC_STATE -> KIND?

+  InlineCacheState GetICState() const override { return MONOMORPHIC; }     \
+  DEFINE_TURBOFAN_CODE_STUB(NAME, TurboFanCodeStub)
+
 #define DEFINE_TURBOFAN_BINARY_OP_CODE_STUB(NAME, SUPER)                       \
  public:                                                                       \
   static compiler::Node* Generate(CodeStubAssembler* assembler,                \
                                   compiler::Node* left, compiler::Node* right, \
                                   compiler::Node* context);                    \
   void GenerateAssembly(CodeStubAssembler* assembler) const override {         \
     assembler->Return(Generate(assembler, assembler->Parameter(0),             \
                                assembler->Parameter(1),                        \
                                assembler->Parameter(2)));                      \
   }                                                                            \
@@ skipping 269 matching lines @@
   void BeforeCall(MacroAssembler* masm) const override {}
 
   void AfterCall(MacroAssembler* masm) const override {}
 };
 
 
 class StringLengthStub : public TurboFanCodeStub {
  public:
   explicit StringLengthStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}
 
-  Code::Kind GetCodeKind() const override { return Code::HANDLER; }
-  InlineCacheState GetICState() const override { return MONOMORPHIC; }
-  ExtraICState GetExtraICState() const override { return Code::LOAD_IC; }
-
   DEFINE_CALL_INTERFACE_DESCRIPTOR(LoadWithVector);
-  DEFINE_TURBOFAN_CODE_STUB(StringLength, TurboFanCodeStub);
+  DEFINE_TURBOFAN_HANDLER_CODE_STUB(StringLength, Code::LOAD_IC);
 };
 
 class AddStub final : public TurboFanCodeStub {
  public:
   explicit AddStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(BinaryOp);
   DEFINE_TURBOFAN_BINARY_OP_CODE_STUB(Add, TurboFanCodeStub);
 };
 
@@ skipping 240 matching lines @@
   explicit ToLengthStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(TypeConversion);
   DEFINE_TURBOFAN_CODE_STUB(ToLength, TurboFanCodeStub);
 };
 
 class StoreInterceptorStub : public TurboFanCodeStub {
  public:
   explicit StoreInterceptorStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}
 
-  void GenerateAssembly(CodeStubAssembler* assember) const override;
+  DEFINE_CALL_INTERFACE_DESCRIPTOR(Store);
+  DEFINE_TURBOFAN_HANDLER_CODE_STUB(StoreInterceptor, Code::STORE_IC);
+};
 
-  Code::Kind GetCodeKind() const override { return Code::HANDLER; }
-  ExtraICState GetExtraICState() const override { return Code::STORE_IC; }
-  InlineCacheState GetICState() const override { return MONOMORPHIC; }
+class LoadICMissStub : public TurboFanCodeStub {
+ public:
+  explicit LoadICMissStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}
 
-  DEFINE_CALL_INTERFACE_DESCRIPTOR(Store);
-  DEFINE_CODE_STUB(StoreInterceptor, TurboFanCodeStub);
+  DEFINE_CALL_INTERFACE_DESCRIPTOR(LoadWithVector);
+  DEFINE_TURBOFAN_HANDLER_CODE_STUB(LoadICMiss, Code::LOAD_IC);

[Toon Verwaest, 2016/06/06 13:01:32]

This is not a HANDLER but a STUB. We should probably just get rid of the
distinction at this point since I think it doesn't matter anymore. (It used to,
for harvesting feedback from code objects that would sometimes call e.g., this
miss stub, and sometimes handlers. We had to have a way to distinguish handlers
from the others.)

+};
+
+class LoadICSlowStub : public TurboFanCodeStub {
+ public:
+  explicit LoadICSlowStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}
+
+  DEFINE_CALL_INTERFACE_DESCRIPTOR(LoadWithVector);
+  DEFINE_TURBOFAN_HANDLER_CODE_STUB(LoadICSlow, Code::LOAD_IC);
 };
 
 class LoadIndexedInterceptorStub : public TurboFanCodeStub {
  public:
   explicit LoadIndexedInterceptorStub(Isolate* isolate)
       : TurboFanCodeStub(isolate) {}
 
-  Code::Kind GetCodeKind() const override { return Code::HANDLER; }
-  ExtraICState GetExtraICState() const override { return Code::KEYED_LOAD_IC; }
-  InlineCacheState GetICState() const override { return MONOMORPHIC; }
-
   DEFINE_CALL_INTERFACE_DESCRIPTOR(LoadWithVector);
-  DEFINE_TURBOFAN_CODE_STUB(LoadIndexedInterceptor, TurboFanCodeStub);
+  DEFINE_TURBOFAN_HANDLER_CODE_STUB(LoadIndexedInterceptor,
+                                    Code::KEYED_LOAD_IC);
 };
 
 // ES6 section 12.10.3 "in" operator evaluation.
 class HasPropertyStub : public TurboFanCodeStub {
  public:
   explicit HasPropertyStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(HasProperty);
   DEFINE_TURBOFAN_BINARY_OP_CODE_STUB(HasProperty, TurboFanCodeStub);
 };
@@ skipping 542 matching lines @@
  public:
   LoadApiGetterStub(Isolate* isolate, bool receiver_is_holder, int index)
       : TurboFanCodeStub(isolate) {
     // If that's not true, we need to ensure that the receiver is actually a
     // JSReceiver. http://crbug.com/609134
     DCHECK(receiver_is_holder);
     minor_key_ = IndexBits::encode(index) |
                  ReceiverIsHolderBits::encode(receiver_is_holder);
   }
 
-  Code::Kind GetCodeKind() const override { return Code::HANDLER; }
-  ExtraICState GetExtraICState() const override { return Code::LOAD_IC; }
-  InlineCacheState GetICState() const override { return MONOMORPHIC; }
-
   int index() const { return IndexBits::decode(minor_key_); }
   bool receiver_is_holder() const {
     return ReceiverIsHolderBits::decode(minor_key_);
   }
 
  private:
   class ReceiverIsHolderBits : public BitField<bool, 0, 1> {};
   class IndexBits : public BitField<int, 1, kDescriptorIndexBitCount> {};
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(Load);
-  DEFINE_TURBOFAN_CODE_STUB(LoadApiGetter, TurboFanCodeStub);
+  DEFINE_TURBOFAN_HANDLER_CODE_STUB(LoadApiGetter, Code::LOAD_IC);
 };
 
 class StoreFieldStub : public HandlerStub {
  public:
   StoreFieldStub(Isolate* isolate, FieldIndex index,
                  Representation representation)
       : HandlerStub(isolate) {
     int property_index_key = index.GetFieldAccessStubKey();
     uint8_t repr = PropertyDetails::EncodeRepresentation(representation);
     set_sub_minor_key(StoreFieldByIndexBits::encode(property_index_key) |
@@ skipping 1721 matching lines @@
 #undef DEFINE_HYDROGEN_CODE_STUB
 #undef DEFINE_CODE_STUB
 #undef DEFINE_CODE_STUB_BASE
 
 extern Representation RepresentationFromType(Type* type);
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_CODE_STUBS_H_