Add a MathFloor stub generated with TurboFan

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(NumberToString)                         \
   V(Typeof)                                 \
   V(RegExpConstructResult)                  \
   V(StoreFastElement)                       \
   V(StoreScriptContextField)                \
   V(StringAdd)                              \
   V(ToBoolean)                              \
   V(TransitionElementsKind)                 \
   V(VectorRawKeyedLoad)                     \
   V(VectorRawLoad)                          \
+  /* TurboFanCodeStubs */                   \
+  V(StringLengthTF)                         \
+  V(MathFloor)                              \
   /* IC Handler stubs */                    \
   V(ArrayBufferViewLoadField)               \
   V(LoadConstant)                           \
   V(LoadField)                              \
   V(KeyedLoadSloppyArguments)               \
   V(StoreField)                             \
   V(StoreGlobal)                            \
   V(StoreTransition)                        \
   V(StringLength)                           \
   V(RestParamAccess)
@@ skipping 43 matching lines @@
 #endif
 
 // Combined list of code stubs.
 #define CODE_STUB_LIST(V)         \
   CODE_STUB_LIST_ALL_PLATFORMS(V) \
   CODE_STUB_LIST_ARM(V)           \
   CODE_STUB_LIST_ARM64(V)         \
   CODE_STUB_LIST_PPC(V)           \
   CODE_STUB_LIST_MIPS(V)
 
+static const int kHasReturnedMinusZeroSentinel = 1;
+
 // Stub is base classes of all stubs.
 class CodeStub BASE_EMBEDDED {
  public:
   enum Major {
     // TODO(mvstanton): eliminate the NoCache key by getting rid
     //                  of the non-monomorphic-cache.
     NoCache = 0,  // marker for stubs that do custom caching]
 #define DEF_ENUM(name) name,
     CODE_STUB_LIST(DEF_ENUM)
 #undef DEF_ENUM
@@ skipping 34 matching lines @@
   // true, which will cause an assertion if we try to call something that can
   // GC or if we try to put a stack frame on top of the junk, which would not
   // result in a traversable stack.
   virtual bool SometimesSetsUpAFrame() { return true; }
 
   // Lookup the code in the (possibly custom) cache.
   bool FindCodeInCache(Code** code_out);
 
   virtual CallInterfaceDescriptor GetCallInterfaceDescriptor() = 0;
 
+  virtual int GetStackParameterCount() const { return 0; }
+
   virtual void InitializeDescriptor(CodeStubDescriptor* descriptor) {}
 
   static void InitializeDescriptor(Isolate* isolate, uint32_t key,
                                    CodeStubDescriptor* desc);
 
   static MaybeHandle<Code> GetCode(Isolate* isolate, uint32_t key);
 
   // Returns information for computing the number key.
   virtual Major MajorKey() const = 0;
   uint32_t MinorKey() const { return minor_key_; }
@@ skipping 122 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_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());                           \
   }
@@ skipping 150 matching lines @@
  private:
   class IsMissBits : public BitField<bool, kSubMinorKeyBits, 1> {};
   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;
+
+  virtual const char* GetFunctionName() const = 0;
+
+ protected:
+  explicit TurboFanCodeStub(Isolate* isolate) : CodeStub(isolate) {}
+
+ private:
+  DEFINE_CODE_STUB_BASE(TurboFanCodeStub, CodeStub);
+};
+
+
 // Helper interface to prepare to/restore after making runtime calls.
 class RuntimeCallHelper {
  public:
   virtual ~RuntimeCallHelper() {}
 
   virtual void BeforeCall(MacroAssembler* masm) const = 0;
 
   virtual void AfterCall(MacroAssembler* masm) const = 0;
 
  protected:
@@ skipping 46 matching lines @@
 class NopRuntimeCallHelper : public RuntimeCallHelper {
  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);
+};
+
+
+class StringLengthTFStub : public TurboFanCodeStub {
+  DEFINE_TURBOFAN_CODE_STUB(StringLengthTF, TurboFanCodeStub, LoadDescriptor,
+                            0);
+
+ public:
+  Code::Kind GetCodeKind() const override { return Code::HANDLER; }
+  InlineCacheState GetICState() const override { return MONOMORPHIC; }
+  ExtraICState GetExtraICState() const override { return Code::LOAD_IC; }
+};
+
+
 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 2238 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_