[Code Stubs] Convert FastNewClosureStub to a TurboFanCodeStub.

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 45 matching lines @@
   /* HydrogenCodeStubs */                   \
   V(BinaryOpIC)                             \
   V(BinaryOpWithAllocationSite)             \
   V(CreateAllocationSite)                   \
   V(CreateWeakCell)                         \
   V(ElementsTransitionAndStore)             \
   V(FastArrayPush)                          \
   V(FastCloneRegExp)                        \
   V(FastCloneShallowArray)                  \
   V(FastFunctionBind)                       \
-  V(FastNewClosure)                         \
   V(FastNewContext)                         \
   V(FastNewObject)                          \
   V(FastNewRestParameter)                   \
   V(FastNewSloppyArguments)                 \
   V(FastNewStrictArguments)                 \
   V(GrowArrayElements)                      \
   V(KeyedLoadGeneric)                       \
   V(LoadScriptContextField)                 \
   V(LoadDictionaryElement)                  \
   V(NameDictionaryLookup)                   \
@@ skipping 34 matching lines @@
   V(ShiftRightLogical)                      \
   V(ShiftLeft)                              \
   V(BitwiseAnd)                             \
   V(BitwiseOr)                              \
   V(BitwiseXor)                             \
   V(Inc)                                    \
   V(InternalArrayNoArgumentConstructor)     \
   V(InternalArraySingleArgumentConstructor) \
   V(Dec)                                    \
   V(FastCloneShallowObject)                 \
+  V(FastNewClosure)                         \
   V(InstanceOf)                             \
   V(LessThan)                               \
   V(LessThanOrEqual)                        \
   V(GreaterThan)                            \
   V(GreaterThanOrEqual)                     \
   V(Equal)                                  \
   V(NotEqual)                               \
   V(StrictEqual)                            \
   V(StrictNotEqual)                         \
   V(StringEqual)                            \
@@ skipping 896 matching lines @@
 
   // 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 HydrogenCodeStub {
+class FastNewClosureStub : public TurboFanCodeStub {
  public:
   FastNewClosureStub(Isolate* isolate, LanguageMode language_mode,
                      FunctionKind kind)
-      : HydrogenCodeStub(isolate) {
+      : TurboFanCodeStub(isolate) {
     DCHECK(IsValidFunctionKind(kind));
-    set_sub_minor_key(LanguageModeBits::encode(language_mode) |
-                      FunctionKindBits::encode(kind));
+    minor_key_ = (LanguageModeBits::encode(language_mode) |

[Benedikt Meurer, 2016/06/27 18:33:55]

So both the language_mode and the kind are deriv(ed|able) from the
SharedFunctionInfo and we pass in the SharedFunctionInfo. How about computing
the map index at runtime (making the encoding more cleverish could help)? Then
we don't need any minor key at all, but a single code object can handle
everything (similar to the byte code handler then).

[rmcilroy, 2016/06/29 21:11:48]

Done. PTAL, thanks.

+                  FunctionKindBits::encode(kind));
   }
 
+  static compiler::Node* Generate(CodeStubAssembler* assembler,
+                                  compiler::Node* shared_info,
+                                  compiler::Node* map_index,
+                                  compiler::Node* context);
+
   LanguageMode language_mode() const {
-    return LanguageModeBits::decode(sub_minor_key());
+    return LanguageModeBits::decode(MinorKey());
   }
 
-  FunctionKind kind() const {
-    return FunctionKindBits::decode(sub_minor_key());
-  }
+  FunctionKind kind() const { return FunctionKindBits::decode(MinorKey()); }
 
  private:
   STATIC_ASSERT(LANGUAGE_END == 3);
   class LanguageModeBits : public BitField<LanguageMode, 0, 2> {};
   class FunctionKindBits : public BitField<FunctionKind, 2, 9> {};
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(FastNewClosure);
-  DEFINE_HYDROGEN_CODE_STUB(FastNewClosure, HydrogenCodeStub);
+  DEFINE_TURBOFAN_CODE_STUB(FastNewClosure, TurboFanCodeStub);
 };
 
 
 class FastNewContextStub final : public HydrogenCodeStub {
  public:
   static const int kMaximumSlots = 64;
 
   FastNewContextStub(Isolate* isolate, int slots) : HydrogenCodeStub(isolate) {
     DCHECK(slots >= 0 && slots <= kMaximumSlots);
     set_sub_minor_key(SlotsBits::encode(slots));
@@ skipping 2040 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_