src/code-stubs.h - v8/v8.git - Git at Google

 // 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/interface-descriptors.h"
 #include "src/type-hints.h"

 namespace v8 {
 namespace internal {

 // Forward declarations.
 class Isolate;
 namespace compiler {
 class CodeAssemblerState;
 }

 // List of code stubs used on all platforms.
 #define CODE_STUB_LIST_ALL_PLATFORMS(V)     \
   /* --- PlatformCodeStubs --- */           \
   V(CallApiCallback)                        \
   V(CallApiGetter)                          \
   V(JSEntry)                                \
   V(ProfileEntryHook)                       \
   /* --- TurboFanCodeStubs --- */           \
   V(StoreSlowElement)                       \
   V(StoreInArrayLiteralSlow)                \
   V(ElementsTransitionAndStore)             \
   V(KeyedLoadSloppyArguments)               \
   V(KeyedStoreSloppyArguments)              \
   V(StoreFastElement)                       \
   V(StoreInterceptor)                       \
   V(LoadIndexedInterceptor)

 // List of code stubs only used on ARM 32 bits platforms.
 #if V8_TARGET_ARCH_ARM
 #define CODE_STUB_LIST_ARM(V) V(DirectCEntry)

 #else
 #define CODE_STUB_LIST_ARM(V)
 #endif

 // List of code stubs only used on ARM 64 bits platforms.
 #if V8_TARGET_ARCH_ARM64
 #define CODE_STUB_LIST_ARM64(V) V(DirectCEntry)

 #else
 #define CODE_STUB_LIST_ARM64(V)
 #endif

 // List of code stubs only used on PPC platforms.
 #ifdef V8_TARGET_ARCH_PPC
 #define CODE_STUB_LIST_PPC(V) V(DirectCEntry)
 #else
 #define CODE_STUB_LIST_PPC(V)
 #endif

 // List of code stubs only used on MIPS platforms.
 #if V8_TARGET_ARCH_MIPS
 #define CODE_STUB_LIST_MIPS(V) V(DirectCEntry)
 #elif V8_TARGET_ARCH_MIPS64
 #define CODE_STUB_LIST_MIPS(V) V(DirectCEntry)
 #else
 #define CODE_STUB_LIST_MIPS(V)
 #endif

 // List of code stubs only used on S390 platforms.
 #ifdef V8_TARGET_ARCH_S390
 #define CODE_STUB_LIST_S390(V) V(DirectCEntry)
 #else
 #define CODE_STUB_LIST_S390(V)
 #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)          \
   CODE_STUB_LIST_S390(V)

 static const int kHasReturnedMinusZeroSentinel = 1;

 class CodeStub : public ZoneObject {
  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
     NUMBER_OF_IDS
   };

   // Retrieve the code for the stub. Generate the code if needed.
   Handle<Code> GetCode();

   static Major MajorKeyFromKey(uint32_t key) {
     return static_cast<Major>(MajorKeyBits::decode(key));
   }
   static uint32_t MinorKeyFromKey(uint32_t key) {
     return MinorKeyBits::decode(key);
   }

   // Gets the major key from a code object that is a code stub or binary op IC.
   static Major GetMajorKey(const Code* code_stub);

   static uint32_t NoCacheKey() { return MajorKeyBits::encode(NoCache); }

   static const char* MajorName(Major major_key);

   explicit CodeStub(Isolate* isolate) : minor_key_(0), isolate_(isolate) {}
   virtual ~CodeStub() {}

   static void GenerateStubsAheadOfTime(Isolate* isolate);

   // Some stubs put untagged junk on the stack that cannot be scanned by the
   // GC.  This means that we must be statically sure that no GC can occur while
   // they are running.  If that is the case they should override this to return
   // 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() const = 0;

   virtual int GetStackParameterCount() const {
     return GetCallInterfaceDescriptor().GetStackParameterCount();
   }

   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_; }

   friend std::ostream& operator<<(std::ostream& os, const CodeStub& s) {
     s.PrintName(os);
     return os;
   }

   Isolate* isolate() const { return isolate_; }
   void set_isolate(Isolate* isolate) {
     DCHECK_NOT_NULL(isolate);
     DCHECK(isolate_ == nullptr || isolate_ == isolate);
     isolate_ = isolate;
   }

   void DeleteStubFromCacheForTesting();

  protected:
   CodeStub(uint32_t key, Isolate* isolate)
       : minor_key_(MinorKeyFromKey(key)), isolate_(isolate) {}

   // Generates the assembler code for the stub.
   virtual Handle<Code> GenerateCode() = 0;

   // Returns whether the code generated for this stub needs to be allocated as
   // a fixed (non-moveable) code object.
   // TODO(jgruber): Only required by DirectCEntryStub. Can be removed when/if
   // that is ported to a builtin.
   virtual Movability NeedsImmovableCode() { return kMovable; }

   virtual void PrintName(std::ostream& os) const;        // NOLINT
   virtual void PrintBaseName(std::ostream& os) const;    // NOLINT
   virtual void PrintState(std::ostream& os) const { ; }  // NOLINT

   // Computes the key based on major and minor.
   uint32_t GetKey() {
     DCHECK(static_cast<int>(MajorKey()) < NUMBER_OF_IDS);
     return MinorKeyBits::encode(MinorKey()) | MajorKeyBits::encode(MajorKey());
   }

   uint32_t minor_key_;

  private:
   // Perform bookkeeping required after code generation when stub code is
   // initially generated.
   void RecordCodeGeneration(Handle<Code> code);

   // Activate newly generated stub. Is called after
   // registering stub in the stub cache.
   virtual void Activate(Code* code) { }

   // We use this dispatch to statically instantiate the correct code stub for
   // the given stub key and call the passed function with that code stub.
   typedef void (*DispatchedCall)(CodeStub* stub, void** value_out);
   static void Dispatch(Isolate* isolate, uint32_t key, void** value_out,
                        DispatchedCall call);

   static void GetCodeDispatchCall(CodeStub* stub, void** value_out);

   STATIC_ASSERT(NUMBER_OF_IDS < (1 << kStubMajorKeyBits));
   class MajorKeyBits: public BitField<uint32_t, 0, kStubMajorKeyBits> {};
   class MinorKeyBits: public BitField<uint32_t,
       kStubMajorKeyBits, kStubMinorKeyBits> {};  // NOLINT

   friend class BreakPointIterator;

   Isolate* isolate_;
 };


 #define DEFINE_CODE_STUB_BASE(NAME, SUPER)                      \
  public:                                                        \
   NAME(uint32_t key, Isolate* isolate) : SUPER(key, isolate) {} \
                                                                 \
  private:                                                       \
   DISALLOW_COPY_AND_ASSIGN(NAME)


 #define DEFINE_CODE_STUB(NAME, SUPER)                      \
  public:                                                   \
   inline Major MajorKey() const override { return NAME; }; \
                                                            \
   DEFINE_CODE_STUB_BASE(NAME##Stub, SUPER)


 #define DEFINE_PLATFORM_CODE_STUB(NAME, SUPER)  \
  private:                                       \
   void Generate(MacroAssembler* masm) override; \
   DEFINE_CODE_STUB(NAME, SUPER)


 #define DEFINE_TURBOFAN_CODE_STUB(NAME, SUPER)                               \
  public:                                                                     \
   void GenerateAssembly(compiler::CodeAssemblerState* state) const override; \
   DEFINE_CODE_STUB(NAME, SUPER)

 #define DEFINE_CALL_INTERFACE_DESCRIPTOR(NAME)                          \
  public:                                                                \
   typedef NAME##Descriptor Descriptor;                                  \
   CallInterfaceDescriptor GetCallInterfaceDescriptor() const override { \
     return Descriptor();                                                \
   }

 // 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() const override { \
     UNREACHABLE();                                                      \
     return CallInterfaceDescriptor();                                   \
   }


 class PlatformCodeStub : public CodeStub {
  public:
   // Retrieve the code for the stub. Generate the code if needed.
   Handle<Code> GenerateCode() override;

  protected:
   explicit PlatformCodeStub(Isolate* isolate) : CodeStub(isolate) {}

   // Generates the assembler code for the stub.
   virtual void Generate(MacroAssembler* masm) = 0;

   // Generates the exception handler table for the stub.
   virtual int GenerateHandlerTable(MacroAssembler* masm);

   DEFINE_CODE_STUB_BASE(PlatformCodeStub, CodeStub);
 };


 enum StubFunctionMode { NOT_JS_FUNCTION_STUB_MODE, JS_FUNCTION_STUB_MODE };


 class CodeStubDescriptor {
  public:
   explicit CodeStubDescriptor(CodeStub* stub);

   CodeStubDescriptor(Isolate* isolate, uint32_t stub_key);

   void Initialize(Address deoptimization_handler = kNullAddress,
                   int hint_stack_parameter_count = -1,
                   StubFunctionMode function_mode = NOT_JS_FUNCTION_STUB_MODE);
   void Initialize(Register stack_parameter_count,
                   Address deoptimization_handler = kNullAddress,
                   int hint_stack_parameter_count = -1,
                   StubFunctionMode function_mode = NOT_JS_FUNCTION_STUB_MODE);

   void SetMissHandler(Runtime::FunctionId id) {
     miss_handler_id_ = id;
     miss_handler_ = ExternalReference::Create(Runtime::FunctionForId(id));
     has_miss_handler_ = true;
     // Our miss handler infrastructure doesn't currently support
     // variable stack parameter counts.
     DCHECK(!stack_parameter_count_.is_valid());
   }

   void set_call_descriptor(CallInterfaceDescriptor d) { call_descriptor_ = d; }
   CallInterfaceDescriptor call_descriptor() const { return call_descriptor_; }

   int GetRegisterParameterCount() const {
     return call_descriptor().GetRegisterParameterCount();
   }

   int GetStackParameterCount() const {
     return call_descriptor().GetStackParameterCount();
   }

   int GetParameterCount() const {
     return call_descriptor().GetParameterCount();
   }

   Register GetRegisterParameter(int index) const {
     return call_descriptor().GetRegisterParameter(index);
   }

   MachineType GetParameterType(int index) const {
     return call_descriptor().GetParameterType(index);
   }

   ExternalReference miss_handler() const {
     DCHECK(has_miss_handler_);
     return miss_handler_;
   }

   Runtime::FunctionId miss_handler_id() const {
     DCHECK(has_miss_handler_);
     return miss_handler_id_;
   }

   bool has_miss_handler() const {
     return has_miss_handler_;
   }

   int GetHandlerParameterCount() const {
     int params = GetParameterCount();
     if (PassesArgumentsToDeoptimizationHandler()) {
       params += 1;
     }
     return params;
   }

   int hint_stack_parameter_count() const { return hint_stack_parameter_count_; }
   Register stack_parameter_count() const { return stack_parameter_count_; }
   StubFunctionMode function_mode() const { return function_mode_; }
   Address deoptimization_handler() const { return deoptimization_handler_; }

  private:
   bool PassesArgumentsToDeoptimizationHandler() const {
     return stack_parameter_count_.is_valid();
   }

   Isolate* isolate_;
   CallInterfaceDescriptor call_descriptor_;
   Register stack_parameter_count_;
   // If hint_stack_parameter_count_ > 0, the code stub can optimize the
   // return sequence. Default value is -1, which means it is ignored.
   int hint_stack_parameter_count_;
   StubFunctionMode function_mode_;

   Address deoptimization_handler_;

   ExternalReference miss_handler_;
   Runtime::FunctionId miss_handler_id_;
   bool has_miss_handler_;
 };


 class TurboFanCodeStub : public CodeStub {
  public:
   // Retrieve the code for the stub. Generate the code if needed.
   Handle<Code> GenerateCode() override;

   int GetStackParameterCount() const override {
     return GetCallInterfaceDescriptor().GetStackParameterCount();
   }

  protected:
   explicit TurboFanCodeStub(Isolate* isolate) : CodeStub(isolate) {}

   virtual void GenerateAssembly(compiler::CodeAssemblerState* state) const = 0;

  private:
   DEFINE_CODE_STUB_BASE(TurboFanCodeStub, CodeStub);
 };

 }  // namespace internal
 }  // namespace v8

 #if V8_TARGET_ARCH_IA32
 #elif V8_TARGET_ARCH_X64
 #elif V8_TARGET_ARCH_ARM64
 #include "src/arm64/code-stubs-arm64.h"
 #elif V8_TARGET_ARCH_ARM
 #include "src/arm/code-stubs-arm.h"
 #elif V8_TARGET_ARCH_PPC
 #include "src/ppc/code-stubs-ppc.h"
 #elif V8_TARGET_ARCH_MIPS
 #include "src/mips/code-stubs-mips.h"
 #elif V8_TARGET_ARCH_MIPS64
 #include "src/mips64/code-stubs-mips64.h"
 #elif V8_TARGET_ARCH_S390
 #include "src/s390/code-stubs-s390.h"
 #else
 #error Unsupported target architecture.
 #endif

 namespace v8 {
 namespace internal {

 // TODO(jgruber): Convert this stub into a builtin.
 class StoreInterceptorStub : public TurboFanCodeStub {
  public:
   explicit StoreInterceptorStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}

   DEFINE_CALL_INTERFACE_DESCRIPTOR(StoreWithVector);
   DEFINE_TURBOFAN_CODE_STUB(StoreInterceptor, TurboFanCodeStub);
 };

 // TODO(jgruber): Convert this stub into a builtin.
 class LoadIndexedInterceptorStub : public TurboFanCodeStub {
  public:
   explicit LoadIndexedInterceptorStub(Isolate* isolate)
       : TurboFanCodeStub(isolate) {}

   DEFINE_CALL_INTERFACE_DESCRIPTOR(LoadWithVector);
   DEFINE_TURBOFAN_CODE_STUB(LoadIndexedInterceptor, TurboFanCodeStub);
 };

 // TODO(jgruber): Convert this stub into a builtin.
 class KeyedLoadSloppyArgumentsStub : public TurboFanCodeStub {
  public:
   explicit KeyedLoadSloppyArgumentsStub(Isolate* isolate)
       : TurboFanCodeStub(isolate) {}

  protected:
   DEFINE_CALL_INTERFACE_DESCRIPTOR(LoadWithVector);
   DEFINE_TURBOFAN_CODE_STUB(KeyedLoadSloppyArguments, TurboFanCodeStub);
 };


 class CommonStoreModeBits : public BitField<KeyedAccessStoreMode, 0, 3> {};

 class KeyedStoreSloppyArgumentsStub : public TurboFanCodeStub {
  public:
   explicit KeyedStoreSloppyArgumentsStub(Isolate* isolate,
                                          KeyedAccessStoreMode mode)
       : TurboFanCodeStub(isolate) {
     minor_key_ = CommonStoreModeBits::encode(mode);
   }

  protected:
   DEFINE_CALL_INTERFACE_DESCRIPTOR(StoreWithVector);
   DEFINE_TURBOFAN_CODE_STUB(KeyedStoreSloppyArguments, TurboFanCodeStub);
 };

 class CallApiCallbackStub : public PlatformCodeStub {
  public:
   static const int kArgBits = 7;
   static const int kArgMax = (1 << kArgBits) - 1;

   CallApiCallbackStub(Isolate* isolate, int argc)
       : PlatformCodeStub(isolate) {
     CHECK_LE(0, argc);  // The argc in {0, 1} cases are covered by builtins.
     CHECK_LE(argc, kArgMax);
     minor_key_ = ArgumentBits::encode(argc);
   }

  private:
   int argc() const { return ArgumentBits::decode(minor_key_); }

   class ArgumentBits : public BitField<int, 0, kArgBits> {};

   friend class Builtins;  // For generating the related builtin.

   DEFINE_CALL_INTERFACE_DESCRIPTOR(ApiCallback);
   DEFINE_PLATFORM_CODE_STUB(CallApiCallback, PlatformCodeStub);
 };

 // TODO(jgruber): This stub only exists to avoid code duplication between
 // code-stubs-<arch>.cc and builtins-<arch>.cc. If CallApiCallbackStub is ever
 // completely removed, CallApiGetterStub can also be deleted.
 class CallApiGetterStub : public PlatformCodeStub {
  private:
   // For generating the related builtin.
   explicit CallApiGetterStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
   friend class Builtins;

   DEFINE_CALL_INTERFACE_DESCRIPTOR(ApiGetter);
   DEFINE_PLATFORM_CODE_STUB(CallApiGetter, PlatformCodeStub);
 };

 class JSEntryStub : public PlatformCodeStub {
  public:
   enum class SpecialTarget { kNone, kRunMicrotasks };
   JSEntryStub(Isolate* isolate, StackFrame::Type type)
       : PlatformCodeStub(isolate) {
     DCHECK(type == StackFrame::ENTRY || type == StackFrame::CONSTRUCT_ENTRY);
     minor_key_ = StackFrameTypeBits::encode(type) |
                  SpecialTargetBits::encode(SpecialTarget::kNone);
   }

   JSEntryStub(Isolate* isolate, SpecialTarget target)
       : PlatformCodeStub(isolate) {
     minor_key_ = StackFrameTypeBits::encode(StackFrame::ENTRY) |
                  SpecialTargetBits::encode(target);
   }

  private:
   int GenerateHandlerTable(MacroAssembler* masm) override;

   void PrintName(std::ostream& os) const override {  // NOLINT
     os << (type() == StackFrame::ENTRY ? "JSEntryStub"
                                        : "JSConstructEntryStub");
   }

   StackFrame::Type type() const {
     return StackFrameTypeBits::decode(minor_key_);
   }

   SpecialTarget special_target() const {
     return SpecialTargetBits::decode(minor_key_);
   }

   Handle<Code> EntryTrampoline() {
     switch (special_target()) {
       case SpecialTarget::kNone:
         return (type() == StackFrame::CONSTRUCT_ENTRY)
                    ? BUILTIN_CODE(isolate(), JSConstructEntryTrampoline)
                    : BUILTIN_CODE(isolate(), JSEntryTrampoline);
       case SpecialTarget::kRunMicrotasks:
         return BUILTIN_CODE(isolate(), RunMicrotasks);
     }
     UNREACHABLE();
     return Handle<Code>();
   }

   class StackFrameTypeBits : public BitField<StackFrame::Type, 0, 5> {};
   class SpecialTargetBits
       : public BitField<SpecialTarget, StackFrameTypeBits::kNext, 1> {};

   int handler_offset_;

   DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
   DEFINE_PLATFORM_CODE_STUB(JSEntry, PlatformCodeStub);
 };

 class StoreFastElementStub : public TurboFanCodeStub {
  public:
   StoreFastElementStub(Isolate* isolate, bool is_js_array,
                        ElementsKind elements_kind, KeyedAccessStoreMode mode)
       : TurboFanCodeStub(isolate) {
     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(minor_key_); }

   ElementsKind elements_kind() const {
     return ElementsKindBits::decode(minor_key_);
   }

   KeyedAccessStoreMode store_mode() const {
     return CommonStoreModeBits::decode(minor_key_);
   }

  private:
   class ElementsKindBits
       : public BitField<ElementsKind, CommonStoreModeBits::kNext, 8> {};
   class IsJSArrayBits : public BitField<bool, ElementsKindBits::kNext, 1> {};

   DEFINE_CALL_INTERFACE_DESCRIPTOR(StoreWithVector);
   DEFINE_TURBOFAN_CODE_STUB(StoreFastElement, TurboFanCodeStub);
 };

 class StoreSlowElementStub : public TurboFanCodeStub {
  public:
   StoreSlowElementStub(Isolate* isolate, KeyedAccessStoreMode mode)
       : TurboFanCodeStub(isolate) {
     minor_key_ = CommonStoreModeBits::encode(mode);
   }

  private:
   DEFINE_CALL_INTERFACE_DESCRIPTOR(StoreWithVector);
   DEFINE_TURBOFAN_CODE_STUB(StoreSlowElement, TurboFanCodeStub);
 };

 class StoreInArrayLiteralSlowStub : public TurboFanCodeStub {
  public:
   StoreInArrayLiteralSlowStub(Isolate* isolate, KeyedAccessStoreMode mode)
       : TurboFanCodeStub(isolate) {
     minor_key_ = CommonStoreModeBits::encode(mode);
   }

  private:
   DEFINE_CALL_INTERFACE_DESCRIPTOR(StoreWithVector);
   DEFINE_TURBOFAN_CODE_STUB(StoreInArrayLiteralSlow, TurboFanCodeStub);
 };

 class ElementsTransitionAndStoreStub : public TurboFanCodeStub {
  public:
   ElementsTransitionAndStoreStub(Isolate* isolate, ElementsKind from_kind,
                                  ElementsKind to_kind, bool is_jsarray,
                                  KeyedAccessStoreMode store_mode)
       : TurboFanCodeStub(isolate) {
     minor_key_ = CommonStoreModeBits::encode(store_mode) |
                  FromBits::encode(from_kind) | ToBits::encode(to_kind) |
                  IsJSArrayBits::encode(is_jsarray);
   }

   ElementsKind from_kind() const { return FromBits::decode(minor_key_); }
   ElementsKind to_kind() const { return ToBits::decode(minor_key_); }
   bool is_jsarray() const { return IsJSArrayBits::decode(minor_key_); }
   KeyedAccessStoreMode store_mode() const {
     return CommonStoreModeBits::decode(minor_key_);
   }

  private:
   class FromBits
       : public BitField<ElementsKind, CommonStoreModeBits::kNext, 8> {};
   class ToBits : public BitField<ElementsKind, 11, 8> {};
   class IsJSArrayBits : public BitField<bool, 19, 1> {};

   DEFINE_CALL_INTERFACE_DESCRIPTOR(StoreTransition);
   DEFINE_TURBOFAN_CODE_STUB(ElementsTransitionAndStore, TurboFanCodeStub);
 };

 // TODO(jgruber): Convert this stub into a builtin.
 class ProfileEntryHookStub : public PlatformCodeStub {
  public:
   explicit ProfileEntryHookStub(Isolate* isolate) : PlatformCodeStub(isolate) {}

   // The profile entry hook function is not allowed to cause a GC.
   bool SometimesSetsUpAFrame() override { return false; }

   // Generates a call to the entry hook if it's enabled.
   static void MaybeCallEntryHook(MacroAssembler* masm);
   static void MaybeCallEntryHookDelayed(TurboAssembler* tasm, Zone* zone);

  private:
   static void EntryHookTrampoline(intptr_t function,
                                   intptr_t stack_pointer,
                                   Isolate* isolate);

   // ProfileEntryHookStub is called at the start of a function, so it has the
   // same register set.
   DEFINE_CALL_INTERFACE_DESCRIPTOR(CallFunction)
   DEFINE_PLATFORM_CODE_STUB(ProfileEntryHook, PlatformCodeStub);
 };


 #undef DEFINE_CALL_INTERFACE_DESCRIPTOR
 #undef DEFINE_PLATFORM_CODE_STUB
 #undef DEFINE_CODE_STUB
 #undef DEFINE_CODE_STUB_BASE

 }  // namespace internal
 }  // namespace v8

 #endif  // V8_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/interface-descriptors.h"
	#include "src/type-hints.h"

	namespace v8 {
	namespace internal {

	// Forward declarations.
	class Isolate;
	namespace compiler {
	class CodeAssemblerState;
	}

	// List of code stubs used on all platforms.
	#define CODE_STUB_LIST_ALL_PLATFORMS(V) \
	/* --- PlatformCodeStubs --- */ \
	V(CallApiCallback) \
	V(CallApiGetter) \
	V(JSEntry) \
	V(ProfileEntryHook) \
	/* --- TurboFanCodeStubs --- */ \
	V(StoreSlowElement) \
	V(StoreInArrayLiteralSlow) \
	V(ElementsTransitionAndStore) \
	V(KeyedLoadSloppyArguments) \
	V(KeyedStoreSloppyArguments) \
	V(StoreFastElement) \
	V(StoreInterceptor) \
	V(LoadIndexedInterceptor)

	// List of code stubs only used on ARM 32 bits platforms.
	#if V8_TARGET_ARCH_ARM
	#define CODE_STUB_LIST_ARM(V) V(DirectCEntry)

	#else
	#define CODE_STUB_LIST_ARM(V)
	#endif

	// List of code stubs only used on ARM 64 bits platforms.
	#if V8_TARGET_ARCH_ARM64
	#define CODE_STUB_LIST_ARM64(V) V(DirectCEntry)

	#else
	#define CODE_STUB_LIST_ARM64(V)
	#endif

	// List of code stubs only used on PPC platforms.
	#ifdef V8_TARGET_ARCH_PPC
	#define CODE_STUB_LIST_PPC(V) V(DirectCEntry)
	#else
	#define CODE_STUB_LIST_PPC(V)
	#endif

	// List of code stubs only used on MIPS platforms.
	#if V8_TARGET_ARCH_MIPS
	#define CODE_STUB_LIST_MIPS(V) V(DirectCEntry)
	#elif V8_TARGET_ARCH_MIPS64
	#define CODE_STUB_LIST_MIPS(V) V(DirectCEntry)
	#else
	#define CODE_STUB_LIST_MIPS(V)
	#endif

	// List of code stubs only used on S390 platforms.
	#ifdef V8_TARGET_ARCH_S390
	#define CODE_STUB_LIST_S390(V) V(DirectCEntry)
	#else
	#define CODE_STUB_LIST_S390(V)
	#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) \
	CODE_STUB_LIST_S390(V)

	static const int kHasReturnedMinusZeroSentinel = 1;

	class CodeStub : public ZoneObject {
	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
	NUMBER_OF_IDS
	};

	// Retrieve the code for the stub. Generate the code if needed.
	Handle<Code> GetCode();

	static Major MajorKeyFromKey(uint32_t key) {
	return static_cast<Major>(MajorKeyBits::decode(key));
	}
	static uint32_t MinorKeyFromKey(uint32_t key) {
	return MinorKeyBits::decode(key);
	}

	// Gets the major key from a code object that is a code stub or binary op IC.
	static Major GetMajorKey(const Code* code_stub);

	static uint32_t NoCacheKey() { return MajorKeyBits::encode(NoCache); }

	static const char* MajorName(Major major_key);

	explicit CodeStub(Isolate* isolate) : minor_key_(0), isolate_(isolate) {}
	virtual ~CodeStub() {}

	static void GenerateStubsAheadOfTime(Isolate* isolate);

	// Some stubs put untagged junk on the stack that cannot be scanned by the
	// GC. This means that we must be statically sure that no GC can occur while
	// they are running. If that is the case they should override this to return
	// 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() const = 0;

	virtual int GetStackParameterCount() const {
	return GetCallInterfaceDescriptor().GetStackParameterCount();
	}

	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_; }

	friend std::ostream& operator<<(std::ostream& os, const CodeStub& s) {
	s.PrintName(os);
	return os;
	}

	Isolate* isolate() const { return isolate_; }
	void set_isolate(Isolate* isolate) {
	DCHECK_NOT_NULL(isolate);
	DCHECK(isolate_ == nullptr \|\| isolate_ == isolate);
	isolate_ = isolate;
	}

	void DeleteStubFromCacheForTesting();

	protected:
	CodeStub(uint32_t key, Isolate* isolate)
	: minor_key_(MinorKeyFromKey(key)), isolate_(isolate) {}

	// Generates the assembler code for the stub.
	virtual Handle<Code> GenerateCode() = 0;

	// Returns whether the code generated for this stub needs to be allocated as
	// a fixed (non-moveable) code object.
	// TODO(jgruber): Only required by DirectCEntryStub. Can be removed when/if
	// that is ported to a builtin.
	virtual Movability NeedsImmovableCode() { return kMovable; }

	virtual void PrintName(std::ostream& os) const; // NOLINT
	virtual void PrintBaseName(std::ostream& os) const; // NOLINT
	virtual void PrintState(std::ostream& os) const { ; } // NOLINT

	// Computes the key based on major and minor.
	uint32_t GetKey() {
	DCHECK(static_cast<int>(MajorKey()) < NUMBER_OF_IDS);
	return MinorKeyBits::encode(MinorKey()) \| MajorKeyBits::encode(MajorKey());
	}

	uint32_t minor_key_;

	private:
	// Perform bookkeeping required after code generation when stub code is
	// initially generated.
	void RecordCodeGeneration(Handle<Code> code);

	// Activate newly generated stub. Is called after
	// registering stub in the stub cache.
	virtual void Activate(Code* code) { }

	// We use this dispatch to statically instantiate the correct code stub for
	// the given stub key and call the passed function with that code stub.
	typedef void (DispatchedCall)(CodeStub stub, void** value_out);
	static void Dispatch(Isolate* isolate, uint32_t key, void** value_out,
	DispatchedCall call);

	static void GetCodeDispatchCall(CodeStub* stub, void** value_out);

	STATIC_ASSERT(NUMBER_OF_IDS < (1 << kStubMajorKeyBits));
	class MajorKeyBits: public BitField<uint32_t, 0, kStubMajorKeyBits> {};
	class MinorKeyBits: public BitField<uint32_t,
	kStubMajorKeyBits, kStubMinorKeyBits> {}; // NOLINT

	friend class BreakPointIterator;

	Isolate* isolate_;
	};


	#define DEFINE_CODE_STUB_BASE(NAME, SUPER) \
	public: \
	NAME(uint32_t key, Isolate* isolate) : SUPER(key, isolate) {} \
	\
	private: \
	DISALLOW_COPY_AND_ASSIGN(NAME)


	#define DEFINE_CODE_STUB(NAME, SUPER) \
	public: \
	inline Major MajorKey() const override { return NAME; }; \
	\
	DEFINE_CODE_STUB_BASE(NAME##Stub, SUPER)


	#define DEFINE_PLATFORM_CODE_STUB(NAME, SUPER) \
	private: \
	void Generate(MacroAssembler* masm) override; \
	DEFINE_CODE_STUB(NAME, SUPER)


	#define DEFINE_TURBOFAN_CODE_STUB(NAME, SUPER) \
	public: \
	void GenerateAssembly(compiler::CodeAssemblerState* state) const override; \
	DEFINE_CODE_STUB(NAME, SUPER)

	#define DEFINE_CALL_INTERFACE_DESCRIPTOR(NAME) \
	public: \
	typedef NAME##Descriptor Descriptor; \
	CallInterfaceDescriptor GetCallInterfaceDescriptor() const override { \
	return Descriptor(); \
	}

	// 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() const override { \
	UNREACHABLE(); \
	return CallInterfaceDescriptor(); \
	}


	class PlatformCodeStub : public CodeStub {
	public:
	// Retrieve the code for the stub. Generate the code if needed.
	Handle<Code> GenerateCode() override;

	protected:
	explicit PlatformCodeStub(Isolate* isolate) : CodeStub(isolate) {}

	// Generates the assembler code for the stub.
	virtual void Generate(MacroAssembler* masm) = 0;

	// Generates the exception handler table for the stub.
	virtual int GenerateHandlerTable(MacroAssembler* masm);

	DEFINE_CODE_STUB_BASE(PlatformCodeStub, CodeStub);
	};


	enum StubFunctionMode { NOT_JS_FUNCTION_STUB_MODE, JS_FUNCTION_STUB_MODE };


	class CodeStubDescriptor {
	public:
	explicit CodeStubDescriptor(CodeStub* stub);

	CodeStubDescriptor(Isolate* isolate, uint32_t stub_key);

	void Initialize(Address deoptimization_handler = kNullAddress,
	int hint_stack_parameter_count = -1,
	StubFunctionMode function_mode = NOT_JS_FUNCTION_STUB_MODE);
	void Initialize(Register stack_parameter_count,
	Address deoptimization_handler = kNullAddress,
	int hint_stack_parameter_count = -1,
	StubFunctionMode function_mode = NOT_JS_FUNCTION_STUB_MODE);

	void SetMissHandler(Runtime::FunctionId id) {
	miss_handler_id_ = id;
	miss_handler_ = ExternalReference::Create(Runtime::FunctionForId(id));
	has_miss_handler_ = true;
	// Our miss handler infrastructure doesn't currently support
	// variable stack parameter counts.
	DCHECK(!stack_parameter_count_.is_valid());
	}

	void set_call_descriptor(CallInterfaceDescriptor d) { call_descriptor_ = d; }
	CallInterfaceDescriptor call_descriptor() const { return call_descriptor_; }

	int GetRegisterParameterCount() const {
	return call_descriptor().GetRegisterParameterCount();
	}

	int GetStackParameterCount() const {
	return call_descriptor().GetStackParameterCount();
	}

	int GetParameterCount() const {
	return call_descriptor().GetParameterCount();
	}

	Register GetRegisterParameter(int index) const {
	return call_descriptor().GetRegisterParameter(index);
	}

	MachineType GetParameterType(int index) const {
	return call_descriptor().GetParameterType(index);
	}

	ExternalReference miss_handler() const {
	DCHECK(has_miss_handler_);
	return miss_handler_;
	}

	Runtime::FunctionId miss_handler_id() const {
	DCHECK(has_miss_handler_);
	return miss_handler_id_;
	}

	bool has_miss_handler() const {
	return has_miss_handler_;
	}

	int GetHandlerParameterCount() const {
	int params = GetParameterCount();
	if (PassesArgumentsToDeoptimizationHandler()) {
	params += 1;
	}
	return params;
	}

	int hint_stack_parameter_count() const { return hint_stack_parameter_count_; }
	Register stack_parameter_count() const { return stack_parameter_count_; }
	StubFunctionMode function_mode() const { return function_mode_; }
	Address deoptimization_handler() const { return deoptimization_handler_; }

	private:
	bool PassesArgumentsToDeoptimizationHandler() const {
	return stack_parameter_count_.is_valid();
	}

	Isolate* isolate_;
	CallInterfaceDescriptor call_descriptor_;
	Register stack_parameter_count_;
	// If hint_stack_parameter_count_ > 0, the code stub can optimize the
	// return sequence. Default value is -1, which means it is ignored.
	int hint_stack_parameter_count_;
	StubFunctionMode function_mode_;

	Address deoptimization_handler_;

	ExternalReference miss_handler_;
	Runtime::FunctionId miss_handler_id_;
	bool has_miss_handler_;
	};


	class TurboFanCodeStub : public CodeStub {
	public:
	// Retrieve the code for the stub. Generate the code if needed.
	Handle<Code> GenerateCode() override;

	int GetStackParameterCount() const override {
	return GetCallInterfaceDescriptor().GetStackParameterCount();
	}

	protected:
	explicit TurboFanCodeStub(Isolate* isolate) : CodeStub(isolate) {}

	virtual void GenerateAssembly(compiler::CodeAssemblerState* state) const = 0;

	private:
	DEFINE_CODE_STUB_BASE(TurboFanCodeStub, CodeStub);
	};

	} // namespace internal
	} // namespace v8

	#if V8_TARGET_ARCH_IA32
	#elif V8_TARGET_ARCH_X64
	#elif V8_TARGET_ARCH_ARM64
	#include "src/arm64/code-stubs-arm64.h"
	#elif V8_TARGET_ARCH_ARM
	#include "src/arm/code-stubs-arm.h"
	#elif V8_TARGET_ARCH_PPC
	#include "src/ppc/code-stubs-ppc.h"
	#elif V8_TARGET_ARCH_MIPS
	#include "src/mips/code-stubs-mips.h"
	#elif V8_TARGET_ARCH_MIPS64
	#include "src/mips64/code-stubs-mips64.h"
	#elif V8_TARGET_ARCH_S390
	#include "src/s390/code-stubs-s390.h"
	#else
	#error Unsupported target architecture.
	#endif

	namespace v8 {
	namespace internal {

	// TODO(jgruber): Convert this stub into a builtin.
	class StoreInterceptorStub : public TurboFanCodeStub {
	public:
	explicit StoreInterceptorStub(Isolate* isolate) : TurboFanCodeStub(isolate) {}

	DEFINE_CALL_INTERFACE_DESCRIPTOR(StoreWithVector);
	DEFINE_TURBOFAN_CODE_STUB(StoreInterceptor, TurboFanCodeStub);
	};

	// TODO(jgruber): Convert this stub into a builtin.
	class LoadIndexedInterceptorStub : public TurboFanCodeStub {
	public:
	explicit LoadIndexedInterceptorStub(Isolate* isolate)
	: TurboFanCodeStub(isolate) {}

	DEFINE_CALL_INTERFACE_DESCRIPTOR(LoadWithVector);
	DEFINE_TURBOFAN_CODE_STUB(LoadIndexedInterceptor, TurboFanCodeStub);
	};

	// TODO(jgruber): Convert this stub into a builtin.
	class KeyedLoadSloppyArgumentsStub : public TurboFanCodeStub {
	public:
	explicit KeyedLoadSloppyArgumentsStub(Isolate* isolate)
	: TurboFanCodeStub(isolate) {}

	protected:
	DEFINE_CALL_INTERFACE_DESCRIPTOR(LoadWithVector);
	DEFINE_TURBOFAN_CODE_STUB(KeyedLoadSloppyArguments, TurboFanCodeStub);
	};


	class CommonStoreModeBits : public BitField<KeyedAccessStoreMode, 0, 3> {};

	class KeyedStoreSloppyArgumentsStub : public TurboFanCodeStub {
	public:
	explicit KeyedStoreSloppyArgumentsStub(Isolate* isolate,
	KeyedAccessStoreMode mode)
	: TurboFanCodeStub(isolate) {
	minor_key_ = CommonStoreModeBits::encode(mode);
	}

	protected:
	DEFINE_CALL_INTERFACE_DESCRIPTOR(StoreWithVector);
	DEFINE_TURBOFAN_CODE_STUB(KeyedStoreSloppyArguments, TurboFanCodeStub);
	};

	class CallApiCallbackStub : public PlatformCodeStub {
	public:
	static const int kArgBits = 7;
	static const int kArgMax = (1 << kArgBits) - 1;

	CallApiCallbackStub(Isolate* isolate, int argc)
	: PlatformCodeStub(isolate) {
	CHECK_LE(0, argc); // The argc in {0, 1} cases are covered by builtins.
	CHECK_LE(argc, kArgMax);
	minor_key_ = ArgumentBits::encode(argc);
	}

	private:
	int argc() const { return ArgumentBits::decode(minor_key_); }

	class ArgumentBits : public BitField<int, 0, kArgBits> {};

	friend class Builtins; // For generating the related builtin.

	DEFINE_CALL_INTERFACE_DESCRIPTOR(ApiCallback);
	DEFINE_PLATFORM_CODE_STUB(CallApiCallback, PlatformCodeStub);
	};

	// TODO(jgruber): This stub only exists to avoid code duplication between
	// code-stubs-<arch>.cc and builtins-<arch>.cc. If CallApiCallbackStub is ever
	// completely removed, CallApiGetterStub can also be deleted.
	class CallApiGetterStub : public PlatformCodeStub {
	private:
	// For generating the related builtin.
	explicit CallApiGetterStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
	friend class Builtins;

	DEFINE_CALL_INTERFACE_DESCRIPTOR(ApiGetter);
	DEFINE_PLATFORM_CODE_STUB(CallApiGetter, PlatformCodeStub);
	};

	class JSEntryStub : public PlatformCodeStub {
	public:
	enum class SpecialTarget { kNone, kRunMicrotasks };
	JSEntryStub(Isolate* isolate, StackFrame::Type type)
	: PlatformCodeStub(isolate) {
	DCHECK(type == StackFrame::ENTRY \|\| type == StackFrame::CONSTRUCT_ENTRY);
	minor_key_ = StackFrameTypeBits::encode(type) \|
	SpecialTargetBits::encode(SpecialTarget::kNone);
	}

	JSEntryStub(Isolate* isolate, SpecialTarget target)
	: PlatformCodeStub(isolate) {
	minor_key_ = StackFrameTypeBits::encode(StackFrame::ENTRY) \|
	SpecialTargetBits::encode(target);
	}

	private:
	int GenerateHandlerTable(MacroAssembler* masm) override;

	void PrintName(std::ostream& os) const override { // NOLINT
	os << (type() == StackFrame::ENTRY ? "JSEntryStub"
	: "JSConstructEntryStub");
	}

	StackFrame::Type type() const {
	return StackFrameTypeBits::decode(minor_key_);
	}

	SpecialTarget special_target() const {
	return SpecialTargetBits::decode(minor_key_);
	}

	Handle<Code> EntryTrampoline() {
	switch (special_target()) {
	case SpecialTarget::kNone:
	return (type() == StackFrame::CONSTRUCT_ENTRY)
	? BUILTIN_CODE(isolate(), JSConstructEntryTrampoline)
	: BUILTIN_CODE(isolate(), JSEntryTrampoline);
	case SpecialTarget::kRunMicrotasks:
	return BUILTIN_CODE(isolate(), RunMicrotasks);
	}
	UNREACHABLE();
	return Handle<Code>();
	}

	class StackFrameTypeBits : public BitField<StackFrame::Type, 0, 5> {};
	class SpecialTargetBits
	: public BitField<SpecialTarget, StackFrameTypeBits::kNext, 1> {};

	int handler_offset_;

	DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR();
	DEFINE_PLATFORM_CODE_STUB(JSEntry, PlatformCodeStub);
	};

	class StoreFastElementStub : public TurboFanCodeStub {
	public:
	StoreFastElementStub(Isolate* isolate, bool is_js_array,
	ElementsKind elements_kind, KeyedAccessStoreMode mode)
	: TurboFanCodeStub(isolate) {
	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(minor_key_); }

	ElementsKind elements_kind() const {
	return ElementsKindBits::decode(minor_key_);
	}

	KeyedAccessStoreMode store_mode() const {
	return CommonStoreModeBits::decode(minor_key_);
	}

	private:
	class ElementsKindBits
	: public BitField<ElementsKind, CommonStoreModeBits::kNext, 8> {};
	class IsJSArrayBits : public BitField<bool, ElementsKindBits::kNext, 1> {};

	DEFINE_CALL_INTERFACE_DESCRIPTOR(StoreWithVector);
	DEFINE_TURBOFAN_CODE_STUB(StoreFastElement, TurboFanCodeStub);
	};

	class StoreSlowElementStub : public TurboFanCodeStub {
	public:
	StoreSlowElementStub(Isolate* isolate, KeyedAccessStoreMode mode)
	: TurboFanCodeStub(isolate) {
	minor_key_ = CommonStoreModeBits::encode(mode);
	}

	private:
	DEFINE_CALL_INTERFACE_DESCRIPTOR(StoreWithVector);
	DEFINE_TURBOFAN_CODE_STUB(StoreSlowElement, TurboFanCodeStub);
	};

	class StoreInArrayLiteralSlowStub : public TurboFanCodeStub {
	public:
	StoreInArrayLiteralSlowStub(Isolate* isolate, KeyedAccessStoreMode mode)
	: TurboFanCodeStub(isolate) {
	minor_key_ = CommonStoreModeBits::encode(mode);
	}

	private:
	DEFINE_CALL_INTERFACE_DESCRIPTOR(StoreWithVector);
	DEFINE_TURBOFAN_CODE_STUB(StoreInArrayLiteralSlow, TurboFanCodeStub);
	};

	class ElementsTransitionAndStoreStub : public TurboFanCodeStub {
	public:
	ElementsTransitionAndStoreStub(Isolate* isolate, ElementsKind from_kind,
	ElementsKind to_kind, bool is_jsarray,
	KeyedAccessStoreMode store_mode)
	: TurboFanCodeStub(isolate) {
	minor_key_ = CommonStoreModeBits::encode(store_mode) \|
	FromBits::encode(from_kind) \| ToBits::encode(to_kind) \|
	IsJSArrayBits::encode(is_jsarray);
	}

	ElementsKind from_kind() const { return FromBits::decode(minor_key_); }
	ElementsKind to_kind() const { return ToBits::decode(minor_key_); }
	bool is_jsarray() const { return IsJSArrayBits::decode(minor_key_); }
	KeyedAccessStoreMode store_mode() const {
	return CommonStoreModeBits::decode(minor_key_);
	}

	private:
	class FromBits
	: public BitField<ElementsKind, CommonStoreModeBits::kNext, 8> {};
	class ToBits : public BitField<ElementsKind, 11, 8> {};
	class IsJSArrayBits : public BitField<bool, 19, 1> {};

	DEFINE_CALL_INTERFACE_DESCRIPTOR(StoreTransition);
	DEFINE_TURBOFAN_CODE_STUB(ElementsTransitionAndStore, TurboFanCodeStub);
	};

	// TODO(jgruber): Convert this stub into a builtin.
	class ProfileEntryHookStub : public PlatformCodeStub {
	public:
	explicit ProfileEntryHookStub(Isolate* isolate) : PlatformCodeStub(isolate) {}

	// The profile entry hook function is not allowed to cause a GC.
	bool SometimesSetsUpAFrame() override { return false; }

	// Generates a call to the entry hook if it's enabled.
	static void MaybeCallEntryHook(MacroAssembler* masm);
	static void MaybeCallEntryHookDelayed(TurboAssembler* tasm, Zone* zone);

	private:
	static void EntryHookTrampoline(intptr_t function,
	intptr_t stack_pointer,
	Isolate* isolate);

	// ProfileEntryHookStub is called at the start of a function, so it has the
	// same register set.
	DEFINE_CALL_INTERFACE_DESCRIPTOR(CallFunction)
	DEFINE_PLATFORM_CODE_STUB(ProfileEntryHook, PlatformCodeStub);
	};


	#undef DEFINE_CALL_INTERFACE_DESCRIPTOR
	#undef DEFINE_PLATFORM_CODE_STUB
	#undef DEFINE_CODE_STUB
	#undef DEFINE_CODE_STUB_BASE

	} // namespace internal
	} // namespace v8

	#endif // V8_CODE_STUBS_H_