Add a TurboFan skeleton for StringAddStub.

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/codegen.h"
@@ skipping 71 matching lines @@
   V(RegExpConstructResult)                  \
   V(StoreFastElement)                       \
   V(StoreScriptContextField)                \
   V(StringAdd)                              \
   V(ToBoolean)                              \
   V(TransitionElementsKind)                 \
   V(KeyedLoadIC)                            \
   V(LoadIC)                                 \
   /* TurboFanCodeStubs */                   \
   V(StringLengthTF)                         \
+  V(StringAddTF)                            \
   V(MathFloor)                              \
   /* IC Handler stubs */                    \
   V(ArrayBufferViewLoadField)               \
   V(LoadConstant)                           \
   V(LoadFastElement)                        \
   V(LoadField)                              \
   V(KeyedLoadSloppyArguments)               \
   V(StoreField)                             \
   V(StoreGlobal)                            \
   V(StoreTransition)                        \
@@ skipping 245 matching lines @@
   void Generate(MacroAssembler* masm) override; \
   DEFINE_CODE_STUB(NAME, SUPER)
 
 
 #define DEFINE_HYDROGEN_CODE_STUB(NAME, SUPER)                        \
  public:                                                              \
   void InitializeDescriptor(CodeStubDescriptor* descriptor) override; \
   Handle<Code> GenerateCode() override;                               \
   DEFINE_CODE_STUB(NAME, SUPER)
 
-#define DEFINE_TURBOFAN_CODE_STUB(NAME, SUPER, DESC, STACK_PARAMS)     \
- public:                                                               \
-  NAME##Stub(Isolate* isolate) : SUPER(isolate) {}                     \
-  CallInterfaceDescriptor GetCallInterfaceDescriptor() override {      \
-    return DESC(isolate());                                            \
-  };                                                                   \
-  virtual const char* GetFunctionName() const override {               \
-    return #NAME "_STUB";                                              \
-  }                                                                    \
-  int GetStackParameterCount() const override { return STACK_PARAMS; } \
-  Code::StubType GetStubType() const override { return Code::FAST; }   \
+#define DEFINE_TURBOFAN_CODE_STUB(NAME, SUPER)                           \
+ public:                                                                 \
+  const char* GetFunctionName() const override { return #NAME "_STUB"; } \
   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:                                                          \
   CallInterfaceDescriptor GetCallInterfaceDescriptor() override { \
     return NAME##Descriptor(isolate());                           \
   }
 
 // There are some code stubs we just can't describe right now with a
 // CallInterfaceDescriptor. Isolate behavior for those cases with this macro.
 // An attempt to retrieve a descriptor will fail.
 #define DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR()                   \
  public:                                                          \
   CallInterfaceDescriptor GetCallInterfaceDescriptor() override { \
     UNREACHABLE();                                                \
     return CallInterfaceDescriptor();                             \
   }
 
 
 class PlatformCodeStub : public CodeStub {
  public:
   // Retrieve the code for the stub. Generate the code if needed.
   Handle<Code> GenerateCode() override;
 
-  Code::Kind GetCodeKind() const override { return Code::STUB; }
-
  protected:
   explicit PlatformCodeStub(Isolate* isolate) : CodeStub(isolate) {}
 
   // Generates the assembler code for the stub.
   virtual void Generate(MacroAssembler* masm) = 0;
 
   DEFINE_CODE_STUB_BASE(PlatformCodeStub, CodeStub);
 };
 
 
@@ skipping 78 matching lines @@
 };
 
 
 class HydrogenCodeStub : public CodeStub {
  public:
   enum InitializationState {
     UNINITIALIZED,
     INITIALIZED
   };
 
-  Code::Kind GetCodeKind() const override { return Code::STUB; }
-
   template<class SubClass>
   static Handle<Code> GetUninitialized(Isolate* isolate) {
     SubClass::GenerateAheadOfTime(isolate);
     return SubClass().GetCode(isolate);
   }
 
   // Retrieve the code for the stub. Generate the code if needed.
   Handle<Code> GenerateCode() override = 0;
 
   bool IsUninitialized() const { return IsMissBits::decode(minor_key_); }
@@ skipping 23 matching lines @@
   class SubMinorKeyBits : public BitField<int, 0, kSubMinorKeyBits> {};
 
   void GenerateLightweightMiss(MacroAssembler* masm, ExternalReference miss);
 
   DEFINE_CODE_STUB_BASE(HydrogenCodeStub, CodeStub);
 };
 
 
 class TurboFanCodeStub : public CodeStub {
  public:
-  Code::Kind GetCodeKind() const override { return Code::STUB; }
-
   // Retrieve the code for the stub. Generate the code if needed.
   Handle<Code> GenerateCode() override;
 
+  Code::StubType GetStubType() const override { return Code::FAST; }
+
   virtual const char* GetFunctionName() const = 0;
 
  protected:
   explicit TurboFanCodeStub(Isolate* isolate) : CodeStub(isolate) {}
 
  private:
   DEFINE_CODE_STUB_BASE(TurboFanCodeStub, CodeStub);
 };
 
 
@@ skipping 57 matching lines @@
  public:
   NopRuntimeCallHelper() {}
 
   virtual void BeforeCall(MacroAssembler* masm) const {}
 
   virtual void AfterCall(MacroAssembler* masm) const {}
 };
 
 
 class MathFloorStub : public TurboFanCodeStub {
-  DEFINE_TURBOFAN_CODE_STUB(MathFloor, TurboFanCodeStub,
-                            MathRoundVariantDescriptor, 1);
+ public:
+  explicit MathFloorStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}
+  int GetStackParameterCount() const override { return 1; }
+
+  DEFINE_CALL_INTERFACE_DESCRIPTOR(MathRoundVariant);
+  DEFINE_TURBOFAN_CODE_STUB(MathFloor, TurboFanCodeStub);
 };
 
 
 class StringLengthTFStub : public TurboFanCodeStub {
-  DEFINE_TURBOFAN_CODE_STUB(StringLengthTF, TurboFanCodeStub,
-                            LoadWithVectorDescriptor, 0);
+ public:
+  explicit StringLengthTFStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}
 
- public:
   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(StringLengthTF, TurboFanCodeStub);
 };
 
 
+enum StringAddFlags {
+  // Omit both parameter checks.
+  STRING_ADD_CHECK_NONE = 0,
+  // Check left parameter.
+  STRING_ADD_CHECK_LEFT = 1 << 0,
+  // Check right parameter.
+  STRING_ADD_CHECK_RIGHT = 1 << 1,
+  // Check both parameters.
+  STRING_ADD_CHECK_BOTH = STRING_ADD_CHECK_LEFT | STRING_ADD_CHECK_RIGHT
+};
+
+
+std::ostream& operator<<(std::ostream& os, const StringAddFlags& flags);
+
+
+class StringAddTFStub : public TurboFanCodeStub {
+ public:
+  StringAddTFStub(Isolate* isolate, StringAddFlags flags,
+                  PretenureFlag pretenure_flag)
+      : TurboFanCodeStub(isolate) {
+    minor_key_ = StringAddFlagsBits::encode(flags) |
+                 PretenureFlagBits::encode(pretenure_flag);
+  }
+
+  StringAddFlags flags() const {
+    return StringAddFlagsBits::decode(MinorKey());
+  }
+
+  PretenureFlag pretenure_flag() const {
+    return PretenureFlagBits::decode(MinorKey());
+  }
+
+ private:
+  class StringAddFlagsBits : public BitField<StringAddFlags, 0, 2> {};
+  class PretenureFlagBits : public BitField<PretenureFlag, 2, 1> {};
+
+  void PrintBaseName(std::ostream& os) const override;  // NOLINT
+
+  DEFINE_CALL_INTERFACE_DESCRIPTOR(StringAdd);
+  DEFINE_TURBOFAN_CODE_STUB(StringAddTF, TurboFanCodeStub);
+};
+
+
 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(NumberToString);
   DEFINE_HYDROGEN_CODE_STUB(NumberToString, HydrogenCodeStub);
 };
@@ skipping 816 matching lines @@
   // 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);
 };
 
 
-enum StringAddFlags {
-  // Omit both parameter checks.
-  STRING_ADD_CHECK_NONE = 0,
-  // Check left parameter.
-  STRING_ADD_CHECK_LEFT = 1 << 0,
-  // Check right parameter.
-  STRING_ADD_CHECK_RIGHT = 1 << 1,
-  // Check both parameters.
-  STRING_ADD_CHECK_BOTH = STRING_ADD_CHECK_LEFT | STRING_ADD_CHECK_RIGHT
-};
-
-
 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 {
@@ skipping 286 matching lines @@
  public:
   explicit RestParamAccessStub(Isolate* isolate) : PlatformCodeStub(isolate) { }
 
   CallInterfaceDescriptor GetCallInterfaceDescriptor() override {
     return ContextOnlyDescriptor(isolate());
   }
 
  private:
   void GenerateNew(MacroAssembler* masm);
 
-  virtual void PrintName(std::ostream& os) const override;  // NOLINT
+  void PrintName(std::ostream& os) const override;  // NOLINT
 
   DEFINE_PLATFORM_CODE_STUB(RestParamAccess, PlatformCodeStub);
 };
 
 
 class RegExpExecStub: public PlatformCodeStub {
  public:
   explicit RegExpExecStub(Isolate* isolate) : PlatformCodeStub(isolate) { }
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(ContextOnly);
@@ skipping 365 matching lines @@
 
 class LoadICStub : public PlatformCodeStub {
  public:
   explicit LoadICStub(Isolate* isolate, const LoadICState& state)
       : PlatformCodeStub(isolate) {
     minor_key_ = state.GetExtraICState();
   }
 
   void GenerateForTrampoline(MacroAssembler* masm);
 
-  virtual Code::Kind GetCodeKind() const override { return Code::LOAD_IC; }
+  Code::Kind GetCodeKind() const override { return Code::LOAD_IC; }
 
-  virtual InlineCacheState GetICState() const final override { return DEFAULT; }
+  InlineCacheState GetICState() const final override { return DEFAULT; }
 
-  virtual ExtraICState GetExtraICState() const final override {
+  ExtraICState GetExtraICState() const final override {
     return static_cast<ExtraICState>(minor_key_);
   }
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(LoadWithVector);
   DEFINE_PLATFORM_CODE_STUB(LoadIC, PlatformCodeStub);
 
  protected:
   void GenerateImpl(MacroAssembler* masm, bool in_frame);
 };
 
 
 class KeyedLoadICStub : public PlatformCodeStub {
  public:
   explicit KeyedLoadICStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
 
   void GenerateForTrampoline(MacroAssembler* masm);
 
-  virtual Code::Kind GetCodeKind() const override {
-    return Code::KEYED_LOAD_IC;
-  }
+  Code::Kind GetCodeKind() const override { return Code::KEYED_LOAD_IC; }
 
-  virtual InlineCacheState GetICState() const final override { return DEFAULT; }
+  InlineCacheState GetICState() const final override { return DEFAULT; }
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(LoadWithVector);
   DEFINE_PLATFORM_CODE_STUB(KeyedLoadIC, PlatformCodeStub);
 
  protected:
   void GenerateImpl(MacroAssembler* masm, bool in_frame);
 };
 
 
 class DoubleToIStub : public PlatformCodeStub {
@@ skipping 635 matching lines @@
 
 #undef DEFINE_CALL_INTERFACE_DESCRIPTOR
 #undef DEFINE_PLATFORM_CODE_STUB
 #undef DEFINE_HANDLER_CODE_STUB
 #undef DEFINE_HYDROGEN_CODE_STUB
 #undef DEFINE_CODE_STUB
 #undef DEFINE_CODE_STUB_BASE
 } }  // namespace v8::internal
 
 #endif  // V8_CODE_STUBS_H_