#include "config.h"

#include "JITThunks.h"

#if ENABLE(JIT)

#include "CommonSlowPaths.h"

#include "JIT.h"

#include "JITCode.h"

#include "JSCJSValueInlines.h"

#include "LLIntThunks.h"

#include "SlowPathCall.h"

#include "ThunkGenerators.h"

#include "VM.h"

#include "YarrJIT.h"

#include <array>

#include <mutex>

#include <wtf/NeverDestroyed.h>

#include <wtf/TZoneMallocInlines.h>

namespace JSC {

WTF_MAKE_TZONE_ALLOCATED_IMPL(JITThunks);

JITThunks::JITThunks() = default;

JITThunks::~JITThunks() = default;

using SharedCommonThunks = std::array<MacroAssemblerCodeRef<JITThunkPtrTag>, numberOfVMIndependentCommonThunkIDs>;

static const SharedCommonThunks& sharedCommonThunks()

{

static LazyNeverDestroyed<SharedCommonThunks> thunks;

static std::once_flag onceKey;

std::call_once(onceKey, [] {

thunks.construct();

unsigned index = 0;

#define JSC_DEFINE_SHARED_JIT_THUNK(name, func) thunks.get()[index++] = func();

JSC_FOR_EACH_VM_INDEPENDENT_COMMON_THUNK(JSC_DEFINE_SHARED_JIT_THUNK)

#undef JSC_DEFINE_SHARED_JIT_THUNK

});

return thunks.get();

}

static ThunkGenerator generatorForLazyCommonThunk(CommonJITThunkID thunkID)

}

void JITThunks::initialize(VM& vm)

}

static inline NativeExecutable& NODELETE getMayBeDyingNativeExecutable(const Weak<NativeExecutable>& weak)

{

// This never gets Deleted / Empty slots.

WeakImpl* impl = weak.unsafeImpl();

ASSERT(impl);

// We have a callback removing entry when finalizing. This means that we never hold Deallocated entry in HashSet.

ASSERT(impl->state() != WeakImpl::State::Deallocated);

// Never use jsCast here. This is possible that this value is "Dead" but not "Finalized" yet. In this case,

// we can still access to non-JS data, as we are doing in a finalize callback.

auto* executable = static_cast<NativeExecutable*>(impl->jsValue().asCell());

ASSERT(executable);

return *executable;

}

inline unsigned JITThunks::WeakNativeExecutableHash::hash(const NativeExecutable* executable)

{

return hash(executable->function(), executable->constructor(), executable->implementationVisibility(), executable->length(), executable->name());

}

inline unsigned JITThunks::WeakNativeExecutableHash::hash(const Weak<NativeExecutable>& key)

{

return hash(&getMayBeDyingNativeExecutable(key));

}

inline bool JITThunks::WeakNativeExecutableHash::equal(const NativeExecutable& a, const NativeExecutable& b)

{

if (&a == &b)

return true;

return a.function() == b.function() && a.constructor() == b.constructor() && a.implementationVisibility() == b.implementationVisibility() && a.length() == b.length() && a.name() == b.name();

}

inline bool JITThunks::WeakNativeExecutableHash::equal(const Weak<NativeExecutable>& a, const Weak<NativeExecutable>& b)

{

return equal(getMayBeDyingNativeExecutable(a), getMayBeDyingNativeExecutable(b));

}

inline bool JITThunks::WeakNativeExecutableHash::equal(const Weak<NativeExecutable>& a, const NativeExecutable* bExecutable)

{

return equal(getMayBeDyingNativeExecutable(a), *bExecutable);

}

inline bool JITThunks::WeakNativeExecutableHash::equal(const Weak<NativeExecutable>& a, const HostFunctionKey& b)

{

auto& aExecutable = getMayBeDyingNativeExecutable(a);

return aExecutable.function() == std::get<0>(b) && aExecutable.constructor() == std::get<1>(b) && aExecutable.implementationVisibility() == std::get<2>(b) && aExecutable.length() == std::get<3>(b) && aExecutable.name() == std::get<4>(b);

}

CodePtr<JITThunkPtrTag> JITThunks::ctiNativeCall(VM& vm)

}

CodePtr<JITThunkPtrTag> JITThunks::ctiNativeCallWithDebuggerHook(VM& vm)

}

CodePtr<JITThunkPtrTag> JITThunks::ctiNativeConstruct(VM& vm)

}

CodePtr<JITThunkPtrTag> JITThunks::ctiNativeConstructWithDebuggerHook(VM& vm)

}

CodePtr<JITThunkPtrTag> JITThunks::ctiNativeTailCall(VM& vm)

}

CodePtr<JITThunkPtrTag> JITThunks::ctiNativeTailCallWithoutSavedTags(VM& vm)

}

CodePtr<JITThunkPtrTag> JITThunks::ctiInternalFunctionCall(VM& vm)

}

CodePtr<JITThunkPtrTag> JITThunks::ctiInternalFunctionConstruct(VM& vm)

}

template <typename GenerateThunk>

MacroAssemblerCodeRef<JITThunkPtrTag> JITThunks::ctiStubImpl(ThunkGenerator key, GenerateThunk generateThunk)

}

MacroAssemblerCodeRef<JITThunkPtrTag> JITThunks::ctiStub(VM& vm, ThunkGenerator generator)

}

MacroAssemblerCodeRef<JITThunkPtrTag> JITThunks::ctiStub(VM& vm, CommonJITThunkID thunkID)

}

MacroAssemblerCodeRef<JITThunkPtrTag> JITThunks::lazyCommonThunk(VM& vm, CommonJITThunkID thunkID)

}

MacroAssemblerCodeRef<JITThunkPtrTag> JITThunks::ctiSlowPathFunctionStub(VM& vm, SlowPathFunction slowPathFunction)

}

struct JITThunks::HostKeySearcher {

static unsigned NODELETE hash(const HostFunctionKey& key) { return WeakNativeExecutableHash::hash(key); }

static bool NODELETE equal(const Weak<NativeExecutable>& a, const HostFunctionKey& b) { return WeakNativeExecutableHash::equal(a, b); }

};

struct JITThunks::NativeExecutableTranslator {

static unsigned NODELETE hash(const NativeExecutable* key) { return WeakNativeExecutableHash::hash(key); }

static bool NODELETE equal(const Weak<NativeExecutable>& a, const NativeExecutable* b) { return WeakNativeExecutableHash::equal(a, b); }

static void translate(Weak<NativeExecutable>& location, NativeExecutable* executable, unsigned)

{

location = Weak<NativeExecutable>(executable, executable->vm().jitStubs.get());

}

};

void JITThunks::finalize(Handle<Unknown> handle, void*)

}

NativeExecutable* JITThunks::hostFunctionStub(VM& vm, TaggedNativeFunction function, TaggedNativeFunction constructor, ImplementationVisibility implementationVisibility, unsigned length, const String& name)

{

return hostFunctionStub(vm, function, constructor, nullptr, implementationVisibility, NoIntrinsic, nullptr, length, name);

}

NativeExecutable* JITThunks::hostFunctionStub(VM& vm, TaggedNativeFunction function, TaggedNativeFunction constructor, ThunkGenerator generator, ImplementationVisibility implementationVisibility, Intrinsic intrinsic, const DOMJIT::Signature* signature, unsigned length, const String& name)

{

ASSERT(!isCompilationThread());

ASSERT(Options::useJIT());

auto hostFunctionKey = std::make_tuple(function, constructor, implementationVisibility, length, name);

{

AssertNoGC assertNoGC;

auto iterator = m_nativeExecutableSet.find<HostKeySearcher>(hostFunctionKey);

if (iterator != m_nativeExecutableSet.end()) {

// It is possible that this returns Weak<> which is Dead, but not finalized.

// We should not use this reference to store value created in the subsequent sequence, since allocating NativeExecutable can cause GC, which changes this Set.

if (auto* executable = iterator->get())

return executable;

}

}

RefPtr<JSC::JITCode> forCall;

if (generator) {

MacroAssemblerCodeRef<JSEntryPtrTag> entry = generator(vm).retagged<JSEntryPtrTag>();

forCall = adoptRef(new DirectJITCode(entry, entry.code(), JITType::HostCallThunk, intrinsic));

} else if (signature)

forCall = adoptRef(new NativeDOMJITCode(MacroAssemblerCodeRef<JSEntryPtrTag>::createSelfManagedCodeRef(ctiNativeCall(vm).retagged<JSEntryPtrTag>()), JITType::HostCallThunk, intrinsic, signature));

else

forCall = adoptRef(new NativeJITCode(MacroAssemblerCodeRef<JSEntryPtrTag>::createSelfManagedCodeRef(ctiNativeCall(vm).retagged<JSEntryPtrTag>()), JITType::HostCallThunk, intrinsic));

Ref<JSC::JITCode> forConstruct = adoptRef(*new NativeJITCode(MacroAssemblerCodeRef<JSEntryPtrTag>::createSelfManagedCodeRef(ctiNativeConstruct(vm).retagged<JSEntryPtrTag>()), JITType::HostCallThunk, NoIntrinsic));

NativeExecutable* nativeExecutable = NativeExecutable::create(vm, forCall.releaseNonNull(), function, WTF::move(forConstruct), constructor, implementationVisibility, length, name);

{

AssertNoGC assertNoGC;

auto addResult = m_nativeExecutableSet.add<NativeExecutableTranslator>(nativeExecutable);

if (!addResult.isNewEntry) {

// Override the existing Weak<NativeExecutable> with the new one since it is dead.

ASSERT(!*addResult.iterator);

*addResult.iterator = Weak<NativeExecutable>(nativeExecutable, this);

ASSERT(*addResult.iterator);

#if ASSERT_ENABLED

auto iterator = m_nativeExecutableSet.find<HostKeySearcher>(hostFunctionKey);

ASSERT(iterator != m_nativeExecutableSet.end());

ASSERT(iterator->get() == nativeExecutable);

ASSERT(iterator->unsafeImpl()->state() == WeakImpl::State::Live);

#endif

}

}

return nativeExecutable;

}

NativeExecutable* JITThunks::hostFunctionStub(VM& vm, TaggedNativeFunction function, ThunkGenerator generator, ImplementationVisibility implementationVisibility, Intrinsic intrinsic, unsigned length, const String& name)

{

return hostFunctionStub(vm, function, callHostFunctionAsConstructor, generator, implementationVisibility, intrinsic, nullptr, length, name);

}

} // namespace JSC

#endif // ENABLE(JIT)