#ifndef V8_CODE_STUBS_H_

#define V8_CODE_STUBS_H_

#include "src/allocation.h"

#include "src/assembler.h"

#include "src/codegen.h"

#include "src/globals.h"

#include "src/ic/ic-state.h"

#include "src/interface-descriptors.h"

#include "src/macro-assembler.h"

#include "src/ostreams.h"

namespace v8 {

namespace internal {

#define CODE_STUB_LIST_ALL_PLATFORMS(V) \

/* PlatformCodeStubs */ \

V(ArgumentsAccess) \

V(ArrayConstructor) \

V(BinaryOpICWithAllocationSite) \

V(CallApiFunction) \

V(CallApiAccessor) \

V(CallApiGetter) \

V(CallConstruct) \

V(CallFunction) \

V(CallIC) \

V(CEntry) \

V(CompareIC) \

V(DoubleToI) \

V(FunctionPrototype) \

V(InstanceOf) \

V(InternalArrayConstructor) \

V(JSEntry) \

V(KeyedLoadICTrampoline) \

V(LoadICTrampoline) \

V(CallICTrampoline) \

V(LoadIndexedInterceptor) \

V(LoadIndexedString) \

V(MathPow) \

V(ProfileEntryHook) \

V(RecordWrite) \

V(RegExpExec) \

V(StoreArrayLiteralElement) \

V(StoreBufferOverflow) \

V(StoreElement) \

V(StringCompare) \

V(StubFailureTrampoline) \

V(SubString) \

V(ToNumber) \

V(ToString) \

V(ToObject) \

V(VectorStoreICTrampoline) \

V(VectorKeyedStoreICTrampoline) \

V(VectorStoreIC) \

V(VectorKeyedStoreIC) \

/* HydrogenCodeStubs */ \

V(AllocateHeapNumber) \

V(ArrayNArgumentsConstructor) \

V(ArrayNoArgumentConstructor) \

V(ArraySingleArgumentConstructor) \

V(BinaryOpIC) \

V(BinaryOpWithAllocationSite) \

V(CompareNilIC) \

V(CreateAllocationSite) \

V(CreateWeakCell) \

V(ElementsTransitionAndStore) \

V(FastCloneShallowArray) \

V(FastCloneShallowObject) \

V(FastNewClosure) \

V(FastNewContext) \

V(GrowArrayElements) \

V(InternalArrayNArgumentsConstructor) \

V(InternalArrayNoArgumentConstructor) \

V(InternalArraySingleArgumentConstructor) \

V(KeyedLoadGeneric) \

V(LoadGlobalViaContext) \

V(LoadScriptContextField) \

V(LoadDictionaryElement) \

V(NameDictionaryLookup) \

V(NumberToString) \

V(Typeof) \

V(RegExpConstructResult) \

V(StoreFastElement) \

V(StoreGlobalViaContext) \

V(StoreScriptContextField) \

V(StringAdd) \

V(ToBoolean) \

V(TransitionElementsKind) \

V(KeyedLoadIC) \

V(LoadIC) \

/* TurboFanCodeStubs */ \

V(StringLengthTF) \

V(StringAddTF) \

/* TurboFanICs */ \

V(MathFloor) \

/* IC Handler stubs */ \

V(ArrayBufferViewLoadField) \

V(LoadConstant) \

V(LoadFastElement) \

V(LoadField) \

V(KeyedLoadSloppyArguments) \

V(KeyedStoreSloppyArguments) \

V(StoreField) \

V(StoreGlobal) \

V(StoreTransition) \

V(StringLength)

#if V8_TARGET_ARCH_ARM

#define CODE_STUB_LIST_ARM(V) V(DirectCEntry)

#else

#define CODE_STUB_LIST_ARM(V)

#endif

#if V8_TARGET_ARCH_ARM64

#define CODE_STUB_LIST_ARM64(V) \

V(DirectCEntry) \

V(RestoreRegistersState) \

V(StoreRegistersState)

#else

#define CODE_STUB_LIST_ARM64(V)

#endif

#ifdef V8_TARGET_ARCH_PPC

#define CODE_STUB_LIST_PPC(V) \

V(DirectCEntry) \

V(StoreRegistersState) \

V(RestoreRegistersState)

#else

#define CODE_STUB_LIST_PPC(V)

#endif

#if V8_TARGET_ARCH_MIPS

#define CODE_STUB_LIST_MIPS(V) \

V(DirectCEntry) \

V(RestoreRegistersState) \

V(StoreRegistersState)

#elif V8_TARGET_ARCH_MIPS64

#define CODE_STUB_LIST_MIPS(V) \

V(DirectCEntry) \

V(RestoreRegistersState) \

V(StoreRegistersState)

#else

#define CODE_STUB_LIST_MIPS(V)

#endif

#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;

class CodeStub BASE_EMBEDDED {

public:

enum Major {

};

// Retrieve the code for the stub. Generate the code if needed.

Handle<Code> GetCode();

// Retrieve the code for the stub, make and return a copy of the code.

Handle<Code> GetCodeCopy(const Code::FindAndReplacePattern& pattern);

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(Code* code_stub) {

return MajorKeyFromKey(code_stub->stub_key());

}

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);

static void GenerateFPStubs(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();

}

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

// BinaryOpStub needs to override this.

virtual Code::Kind GetCodeKind() const;

virtual InlineCacheState GetICState() const { return UNINITIALIZED; }

virtual ExtraICState GetExtraICState() const { return kNoExtraICState; }

virtual Code::StubType GetStubType() const { return Code::NORMAL; }

friend std::ostream& operator<<(std::ostream& os, const CodeStub& s) {

s.PrintName(os);

return os;

}

Isolate* isolate() const { return isolate_; }

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.

virtual bool NeedsImmovableCode() { return false; }

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);

// Finish the code object after it has been generated.

virtual void FinishCode(Handle<Code> code) { }

// Activate newly generated stub. Is called after

// registering stub in the stub cache.

virtual void Activate(Code* code) { }

// Add the code to a specialized cache, specific to an individual

// stub type. Please note, this method must add the code object to a

// roots object, otherwise we will remove the code during GC.

virtual void AddToSpecialCache(Handle<Code> new_object) { }

// Find code in a specialized cache, work is delegated to the specific stub.

virtual bool FindCodeInSpecialCache(Code** code_out) {

return false;

}

// If a stub uses a special cache override this.

virtual bool UseSpecialCache() { return false; }

// 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) \

protected: \

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_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) \

public: \

CallInterfaceDescriptor GetCallInterfaceDescriptor() const override { \

return DESC##Descriptor(isolate()); \

}; \

DEFINE_CODE_STUB(NAME, SUPER)

#define DEFINE_TURBOFAN_IC(NAME, SUPER, DESC) \

public: \

CallInterfaceDescriptor GetCallInterfaceDescriptor() const override { \

if (GetCallMode() == CALL_FROM_OPTIMIZED_CODE) { \

return DESC##CallFromOptimizedCodeDescriptor(isolate()); \

} else { \

return DESC##CallFromUnoptimizedCodeDescriptor(isolate()); \

} \

}; \

\

protected: \

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() const override { \

return NAME##Descriptor(isolate()); \

}

#define DEFINE_NULL_CALL_INTERFACE_DESCRIPTOR() \

public: \

CallInterfaceDescriptor GetCallInterfaceDescriptor() const override { \

UNREACHABLE(); \

return CallInterfaceDescriptor(); \

}

class PlatformCodeStub : public CodeStub {

};

enum StubFunctionMode { NOT_JS_FUNCTION_STUB_MODE, JS_FUNCTION_STUB_MODE };

class CodeStubDescriptor {

};

class HydrogenCodeStub : public CodeStub {

};

class TurboFanCodeStub : public CodeStub {

};

class TurboFanIC : public TurboFanCodeStub {

};

class RuntimeCallHelper {

};

} } // namespace v8::internal

#if V8_TARGET_ARCH_IA32

#include "src/ia32/code-stubs-ia32.h"

#elif V8_TARGET_ARCH_X64

#include "src/x64/code-stubs-x64.h"

#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_X87

#include "src/x87/code-stubs-x87.h"

#else

#error Unsupported target architecture.

#endif

namespace v8 {

namespace internal {

class StubRuntimeCallHelper : public RuntimeCallHelper {

};

class NopRuntimeCallHelper : public RuntimeCallHelper {

};

class MathFloorStub : public TurboFanIC {

};

class StringLengthTFStub : public TurboFanCodeStub {

};

enum StringAddFlags {

};

std::ostream& operator<<(std::ostream& os, const StringAddFlags& flags);

class StringAddTFStub : public TurboFanCodeStub {

};

class NumberToStringStub final : public HydrogenCodeStub {

};

class TypeofStub final : public HydrogenCodeStub {

};

class FastNewClosureStub : public HydrogenCodeStub {

};

class FastNewContextStub final : public HydrogenCodeStub {

};

class FastCloneShallowArrayStub : public HydrogenCodeStub {

};

class FastCloneShallowObjectStub : public HydrogenCodeStub {

};

class CreateAllocationSiteStub : public HydrogenCodeStub {

};

class CreateWeakCellStub : public HydrogenCodeStub {

};

class GrowArrayElementsStub : public HydrogenCodeStub {

};

class InstanceOfStub final : public PlatformCodeStub {

};

enum AllocationSiteOverrideMode {

};

class ArrayConstructorStub: public PlatformCodeStub {

};

class InternalArrayConstructorStub: public PlatformCodeStub {

};

class MathPowStub: public PlatformCodeStub {

};

class CallICStub: public PlatformCodeStub {