[stubs] Call interface descriptors cleanup.

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 413 matching lines @@
   }                                                                    \
   DEFINE_CODE_STUB(NAME, SUPER)
 
 #define DEFINE_HANDLER_CODE_STUB(NAME, SUPER) \
  public:                                      \
   Handle<Code> GenerateCode() override;       \
   DEFINE_CODE_STUB(NAME, SUPER)
 
 #define DEFINE_CALL_INTERFACE_DESCRIPTOR(NAME)                          \
  public:                                                                \
+  typedef NAME##Descriptor Descriptor;                                  \
   CallInterfaceDescriptor GetCallInterfaceDescriptor() const override { \
-    return NAME##Descriptor(isolate());                                 \
+    return Descriptor(isolate());                                       \
   }
 
 #define DEFINE_ON_STACK_CALL_INTERFACE_DESCRIPTOR(PARAMETER_COUNT)         \
  public:                                                                   \
   CallInterfaceDescriptor GetCallInterfaceDescriptor() const override {    \
     return OnStackArgsDescriptorBase::ForArgs(isolate(), PARAMETER_COUNT); \
   }
 
 // There are some code stubs we just can't describe right now with a
 // CallInterfaceDescriptor. Isolate behavior for those cases with this macro.
@@ skipping 570 matching lines @@
 };
 
 
 std::ostream& operator<<(std::ostream& os, const StringAddFlags& flags);
 
 
 class NumberToStringStub final : public HydrogenCodeStub {
  public:
   explicit NumberToStringStub(Isolate* isolate) : HydrogenCodeStub(isolate) {}
 
-  // Parameters accessed via CodeStubGraphBuilder::GetParameter()
-  static const int kNumber = 0;
-
   DEFINE_CALL_INTERFACE_DESCRIPTOR(TypeConversion);
   DEFINE_HYDROGEN_CODE_STUB(NumberToString, HydrogenCodeStub);
 };
 
 
 class TypeofStub final : public HydrogenCodeStub {
  public:
   explicit TypeofStub(Isolate* isolate) : HydrogenCodeStub(isolate) {}
 
-  // Parameters accessed via CodeStubGraphBuilder::GetParameter()
-  static const int kObject = 0;
-
   static void GenerateAheadOfTime(Isolate* isolate);
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(Typeof);
   DEFINE_HYDROGEN_CODE_STUB(Typeof, HydrogenCodeStub);
 };
 
 class FastNewClosureStub : public TurboFanCodeStub {
  public:
   explicit FastNewClosureStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}
 
@@ skipping 390 matching lines @@
     int property_index_key = LoadFieldByIndexBits::decode(sub_minor_key());
     return FieldIndex::FromFieldAccessStubKey(property_index_key);
   }
 
  protected:
   Code::Kind kind() const override { return Code::LOAD_IC; }
 
  private:
   class LoadFieldByIndexBits : public BitField<int, 0, 13> {};
 
+  // TODO(ishell): The stub uses only kReceiver parameter.
+  DEFINE_CALL_INTERFACE_DESCRIPTOR(LoadWithVector);
   DEFINE_HANDLER_CODE_STUB(LoadField, HandlerStub);
 };
 
 
 class KeyedLoadSloppyArgumentsStub : public HandlerStub {
  public:
   explicit KeyedLoadSloppyArgumentsStub(Isolate* isolate)
       : HandlerStub(isolate) {}
 
  protected:
   Code::Kind kind() const override { return Code::KEYED_LOAD_IC; }
 
- private:
+  DEFINE_CALL_INTERFACE_DESCRIPTOR(LoadWithVector);
   DEFINE_HANDLER_CODE_STUB(KeyedLoadSloppyArguments, HandlerStub);
 };
 
 
 class CommonStoreModeBits : public BitField<KeyedAccessStoreMode, 0, 3> {};
 
 class KeyedStoreSloppyArgumentsStub : public HandlerStub {
  public:
   explicit KeyedStoreSloppyArgumentsStub(Isolate* isolate,
                                          KeyedAccessStoreMode mode)
       : HandlerStub(isolate) {
     set_sub_minor_key(CommonStoreModeBits::encode(mode));
   }
 
  protected:
   Code::Kind kind() const override { return Code::KEYED_STORE_IC; }
 
- private:
+  DEFINE_CALL_INTERFACE_DESCRIPTOR(StoreWithVector);
   DEFINE_HANDLER_CODE_STUB(KeyedStoreSloppyArguments, HandlerStub);
 };
 
 
 class LoadConstantStub : public HandlerStub {
  public:
   LoadConstantStub(Isolate* isolate, int constant_index)
       : HandlerStub(isolate) {
     set_sub_minor_key(ConstantIndexBits::encode(constant_index));
   }
 
   int constant_index() const {
     return ConstantIndexBits::decode(sub_minor_key());
   }
 
  protected:
   Code::Kind kind() const override { return Code::LOAD_IC; }
 
  private:
   class ConstantIndexBits : public BitField<int, 0, kSubMinorKeyBits> {};
 
+  // TODO(ishell): The stub uses only kReceiver parameter.
+  DEFINE_CALL_INTERFACE_DESCRIPTOR(LoadWithVector);
   DEFINE_HANDLER_CODE_STUB(LoadConstant, HandlerStub);
 };
 
 class LoadApiGetterStub : public TurboFanCodeStub {
  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);
@@ skipping 38 matching lines @@
     return PropertyDetails::DecodeRepresentation(repr);
   }
 
  protected:
   Code::Kind kind() const override { return Code::STORE_IC; }
 
  private:
   class StoreFieldByIndexBits : public BitField<int, 0, 13> {};
   class RepresentationBits : public BitField<uint8_t, 13, 4> {};
 
+  // TODO(ishell): The stub uses only kReceiver and kValue parameters.
+  DEFINE_CALL_INTERFACE_DESCRIPTOR(StoreWithVector);
   DEFINE_HANDLER_CODE_STUB(StoreField, HandlerStub);
 };
 
 
 // Register and parameter access methods are specified here instead of in
 // the CallInterfaceDescriptor because the stub uses a different descriptor
 // if FLAG_vector_stores is on.
 class StoreTransitionHelper {
  public:
   static Register ReceiverRegister() {
@@ skipping 13 matching lines @@
   }
 
   static Register VectorRegister() {
     return VectorStoreTransitionDescriptor::VectorRegister();
   }
 
   static Register MapRegister() {
     return VectorStoreTransitionDescriptor::MapRegister();
   }
 
-  static int ReceiverIndex() {
-    return StoreTransitionDescriptor::kReceiverIndex;
-  }
+  static int ReceiverIndex() { return StoreTransitionDescriptor::kReceiver; }
 
-  static int NameIndex() { return StoreTransitionDescriptor::kReceiverIndex; }
+  static int NameIndex() { return StoreTransitionDescriptor::kReceiver; }
 
-  static int ValueIndex() { return StoreTransitionDescriptor::kValueIndex; }
+  static int ValueIndex() { return StoreTransitionDescriptor::kValue; }
 
   static int MapIndex() {
-    DCHECK(static_cast<int>(VectorStoreTransitionDescriptor::kMapIndex) ==
-           static_cast<int>(StoreTransitionDescriptor::kMapIndex));
-    return StoreTransitionDescriptor::kMapIndex;
+    DCHECK(static_cast<int>(VectorStoreTransitionDescriptor::kMap) ==
+           static_cast<int>(StoreTransitionDescriptor::kMap));
+    return StoreTransitionDescriptor::kMap;
   }
 
   static int VectorIndex() {
     if (HasVirtualSlotArg()) {
-      return VectorStoreTransitionDescriptor::kVirtualSlotVectorIndex;
+      return VectorStoreTransitionDescriptor::kVirtualSlotVector;
     }
-    return VectorStoreTransitionDescriptor::kVectorIndex;
+    return VectorStoreTransitionDescriptor::kVector;
   }
 
   // Some platforms don't have a slot arg.
   static bool HasVirtualSlotArg() {
     return SlotRegister().is(no_reg);
   }
 };
 
 
 class StoreTransitionStub : public HandlerStub {
@@ skipping 28 matching lines @@
   Representation representation() {
     DCHECK(store_mode() != StoreMapOnly);
     uint8_t repr = RepresentationBits::decode(sub_minor_key());
     return PropertyDetails::DecodeRepresentation(repr);
   }
 
   StoreMode store_mode() const {
     return StoreModeBits::decode(sub_minor_key());
   }
 
-  CallInterfaceDescriptor GetCallInterfaceDescriptor() const override;
-
  protected:
   Code::Kind kind() const override { return Code::STORE_IC; }
+  void InitializeDescriptor(CodeStubDescriptor* descriptor) override;
 
  private:
   class StoreFieldByIndexBits : public BitField<int, 0, 13> {};
   class RepresentationBits : public BitField<uint8_t, 13, 4> {};
   class StoreModeBits : public BitField<StoreMode, 17, 2> {};
 
+  DEFINE_CALL_INTERFACE_DESCRIPTOR(VectorStoreTransition);
   DEFINE_HANDLER_CODE_STUB(StoreTransition, HandlerStub);
 };
 
 
 class StoreGlobalStub : public HandlerStub {
  public:
   StoreGlobalStub(Isolate* isolate, PropertyCellType type,
                   Maybe<PropertyCellConstantType> constant_type,
                   bool check_global)
       : HandlerStub(isolate) {
@@ skipping 45 matching lines @@
   void set_representation(Representation r) {
     set_sub_minor_key(RepresentationBits::update(sub_minor_key(), r.kind()));
   }
 
  private:
   class CellTypeBits : public BitField<PropertyCellType, 0, 2> {};
   class ConstantTypeBits : public BitField<PropertyCellConstantType, 2, 2> {};
   class RepresentationBits : public BitField<Representation::Kind, 4, 8> {};
   class CheckGlobalBits : public BitField<bool, 12, 1> {};
 
+  // TODO(ishell): The stub uses only kValue parameter.
+  DEFINE_CALL_INTERFACE_DESCRIPTOR(StoreWithVector);
   DEFINE_HANDLER_CODE_STUB(StoreGlobal, HandlerStub);
 };
 
-
+// TODO(ishell): remove, once StoreGlobalIC is implemented.
 class StoreGlobalViaContextStub final : public PlatformCodeStub {
  public:
   static const int kMaximumDepth = 15;
 
   StoreGlobalViaContextStub(Isolate* isolate, int depth,
                             LanguageMode language_mode)
       : PlatformCodeStub(isolate) {
     minor_key_ =
         DepthBits::encode(depth) | LanguageModeBits::encode(language_mode);
   }
@@ skipping 90 matching lines @@
   ExtraICState GetExtraICState() const final {
     return static_cast<ExtraICState>(sub_minor_key());
   }
 
   BinaryOpICState state() const {
     return BinaryOpICState(isolate(), GetExtraICState());
   }
 
   void PrintState(std::ostream& os) const final;  // NOLINT
 
-  // Parameters accessed via CodeStubGraphBuilder::GetParameter()
-  static const int kLeft = 0;
-  static const int kRight = 1;
-
  private:
   static void GenerateAheadOfTime(Isolate* isolate,
                                   const BinaryOpICState& state);
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(BinaryOp);
   DEFINE_HYDROGEN_CODE_STUB(BinaryOpIC, HydrogenCodeStub);
 };
 
 
 // TODO(bmeurer): Merge this into the BinaryOpICStub once we have proper tail
@@ skipping 38 matching lines @@
 class BinaryOpWithAllocationSiteStub final : public BinaryOpICStub {
  public:
   BinaryOpWithAllocationSiteStub(Isolate* isolate, Token::Value op)
       : BinaryOpICStub(isolate, op) {}
 
   BinaryOpWithAllocationSiteStub(Isolate* isolate, const BinaryOpICState& state)
       : BinaryOpICStub(isolate, state) {}
 
   Code::Kind GetCodeKind() const final { return Code::STUB; }
 
-  // Parameters accessed via CodeStubGraphBuilder::GetParameter()
-  static const int kAllocationSite = 0;
-  static const int kLeft = 1;
-  static const int kRight = 2;
-
   DEFINE_CALL_INTERFACE_DESCRIPTOR(BinaryOpWithAllocationSite);
   DEFINE_HYDROGEN_CODE_STUB(BinaryOpWithAllocationSite, BinaryOpICStub);
 };
 
 
 class StringAddStub final : public HydrogenCodeStub {
  public:
   StringAddStub(Isolate* isolate, StringAddFlags flags,
                 PretenureFlag pretenure_flag)
       : HydrogenCodeStub(isolate) {
     set_sub_minor_key(StringAddFlagsBits::encode(flags) |
                       PretenureFlagBits::encode(pretenure_flag));
   }
 
   StringAddFlags flags() const {
     return StringAddFlagsBits::decode(sub_minor_key());
   }
 
   PretenureFlag pretenure_flag() const {
     return PretenureFlagBits::decode(sub_minor_key());
   }
 
-  // Parameters accessed via CodeStubGraphBuilder::GetParameter()
-  static const int kLeft = 0;
-  static const int kRight = 1;
-
  private:
   class StringAddFlagsBits : public BitField<StringAddFlags, 0, 3> {};
   class PretenureFlagBits : public BitField<PretenureFlag, 3, 1> {};
 
   void PrintBaseName(std::ostream& os) const override;  // NOLINT
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(StringAdd);
   DEFINE_HYDROGEN_CODE_STUB(StringAdd, HydrogenCodeStub);
 };
 
@@ skipping 143 matching lines @@
   DEFINE_ON_STACK_CALL_INTERFACE_DESCRIPTOR(4);
   DEFINE_PLATFORM_CODE_STUB(RegExpExec, PlatformCodeStub);
 };
 
 
 class RegExpConstructResultStub final : public HydrogenCodeStub {
  public:
   explicit RegExpConstructResultStub(Isolate* isolate)
       : HydrogenCodeStub(isolate) { }
 
-  // Parameters accessed via CodeStubGraphBuilder::GetParameter()
-  static const int kLength = 0;
-  static const int kIndex = 1;
-  static const int kInput = 2;
-
   DEFINE_CALL_INTERFACE_DESCRIPTOR(RegExpConstructResult);
   DEFINE_HYDROGEN_CODE_STUB(RegExpConstructResult, HydrogenCodeStub);
 };
 
 
 // TODO(bmeurer/mvstanton): Turn CallConstructStub into ConstructICStub.
 class CallConstructStub final : public PlatformCodeStub {
  public:
   explicit CallConstructStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
 
@@ skipping 181 matching lines @@
   DEFINE_HYDROGEN_CODE_STUB(LoadDictionaryElement, HydrogenCodeStub);
 };
 
 
 class KeyedLoadGenericStub : public HydrogenCodeStub {
  public:
   explicit KeyedLoadGenericStub(Isolate* isolate) : HydrogenCodeStub(isolate) {}
 
   Code::Kind GetCodeKind() const override { return Code::KEYED_LOAD_IC; }
 
-  DEFINE_CALL_INTERFACE_DESCRIPTOR(Load);
+  DEFINE_CALL_INTERFACE_DESCRIPTOR(LoadWithVector);
   DEFINE_HYDROGEN_CODE_STUB(KeyedLoadGeneric, HydrogenCodeStub);
 };
 
 
 class LoadICTrampolineStub : public PlatformCodeStub {
  public:
   explicit LoadICTrampolineStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
 
   Code::Kind GetCodeKind() const override { return Code::LOAD_IC; }
 
@@ skipping 289 matching lines @@
 
 class LoadScriptContextFieldStub : public ScriptContextFieldStub {
  public:
   LoadScriptContextFieldStub(
       Isolate* isolate, const ScriptContextTable::LookupResult* lookup_result)
       : ScriptContextFieldStub(isolate, lookup_result) {}
 
  private:
   Code::Kind kind() const override { return Code::LOAD_IC; }
 
+  DEFINE_CALL_INTERFACE_DESCRIPTOR(LoadWithVector);
   DEFINE_HANDLER_CODE_STUB(LoadScriptContextField, ScriptContextFieldStub);
 };
 
 
 class StoreScriptContextFieldStub : public ScriptContextFieldStub {
  public:
   StoreScriptContextFieldStub(
       Isolate* isolate, const ScriptContextTable::LookupResult* lookup_result)
       : ScriptContextFieldStub(isolate, lookup_result) {}
 
  private:
   Code::Kind kind() const override { return Code::STORE_IC; }
 
+  DEFINE_CALL_INTERFACE_DESCRIPTOR(StoreWithVector);
   DEFINE_HANDLER_CODE_STUB(StoreScriptContextField, ScriptContextFieldStub);
 };
 
 
 class LoadFastElementStub : public HandlerStub {
  public:
   LoadFastElementStub(Isolate* isolate, bool is_js_array,
                       ElementsKind elements_kind,
                       bool convert_hole_to_undefined = false)
       : HandlerStub(isolate) {
@@ skipping 12 matching lines @@
 
   ElementsKind elements_kind() const {
     return ElementsKindBits::decode(sub_minor_key());
   }
 
  private:
   class ElementsKindBits: public BitField<ElementsKind, 0, 8> {};
   class IsJSArrayBits: public BitField<bool, 8, 1> {};
   class CanConvertHoleToUndefined : public BitField<bool, 9, 1> {};
 
+  DEFINE_CALL_INTERFACE_DESCRIPTOR(LoadWithVector);
   DEFINE_HANDLER_CODE_STUB(LoadFastElement, HandlerStub);
 };
 
 
 class StoreFastElementStub : public HydrogenCodeStub {
  public:
   StoreFastElementStub(Isolate* isolate, bool is_js_array,
                        ElementsKind elements_kind, KeyedAccessStoreMode mode)
       : HydrogenCodeStub(isolate) {
     set_sub_minor_key(CommonStoreModeBits::encode(mode) |
                       ElementsKindBits::encode(elements_kind) |
                       IsJSArrayBits::encode(is_js_array));
   }
 
   static void GenerateAheadOfTime(Isolate* isolate);
 
   bool is_js_array() const { return IsJSArrayBits::decode(sub_minor_key()); }
 
   ElementsKind elements_kind() const {
     return ElementsKindBits::decode(sub_minor_key());
   }
 
   KeyedAccessStoreMode store_mode() const {
     return CommonStoreModeBits::decode(sub_minor_key());
   }
 
-  CallInterfaceDescriptor GetCallInterfaceDescriptor() const override {
-    return StoreWithVectorDescriptor(isolate());
-  }
-
   Code::Kind GetCodeKind() const override { return Code::HANDLER; }
   ExtraICState GetExtraICState() const override { return Code::KEYED_STORE_IC; }
 
  private:
   class ElementsKindBits : public BitField<ElementsKind, 3, 8> {};
   class IsJSArrayBits : public BitField<bool, 11, 1> {};
 
+  DEFINE_CALL_INTERFACE_DESCRIPTOR(StoreWithVector);
   DEFINE_HYDROGEN_CODE_STUB(StoreFastElement, HydrogenCodeStub);
 };
 
 
 class TransitionElementsKindStub : public HydrogenCodeStub {
  public:
   TransitionElementsKindStub(Isolate* isolate, ElementsKind from_kind,
                              ElementsKind to_kind)
       : HydrogenCodeStub(isolate) {
     set_sub_minor_key(FromKindBits::encode(from_kind) |
@@ skipping 275 matching lines @@
                       IsJSArrayBits::encode(is_jsarray));
   }
 
   ElementsKind from_kind() const { return FromBits::decode(sub_minor_key()); }
   ElementsKind to_kind() const { return ToBits::decode(sub_minor_key()); }
   bool is_jsarray() const { return IsJSArrayBits::decode(sub_minor_key()); }
   KeyedAccessStoreMode store_mode() const {
     return CommonStoreModeBits::decode(sub_minor_key());
   }
 
-  CallInterfaceDescriptor GetCallInterfaceDescriptor() const override;
   Code::Kind GetCodeKind() const override { return Code::HANDLER; }
   ExtraICState GetExtraICState() const override { return Code::KEYED_STORE_IC; }
 
  private:
   class FromBits : public BitField<ElementsKind, 3, 8> {};
   class ToBits : public BitField<ElementsKind, 11, 8> {};
   class IsJSArrayBits : public BitField<bool, 19, 1> {};
 
+  DEFINE_CALL_INTERFACE_DESCRIPTOR(VectorStoreTransition);
   DEFINE_HYDROGEN_CODE_STUB(ElementsTransitionAndStore, HydrogenCodeStub);
 };
 
 
 class StubFailureTrampolineStub : public PlatformCodeStub {
  public:
   StubFailureTrampolineStub(Isolate* isolate, StubFunctionMode function_mode)
       : PlatformCodeStub(isolate) {
     minor_key_ = FunctionModeField::encode(function_mode);
   }
@@ skipping 93 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_