#include "config.h"

#include "WebAssemblyFunction.h"

#if ENABLE(WEBASSEMBLY)

#include "JITOpaqueByproducts.h"

#include "JSCJSValueInlines.h"

#include "JSObject.h"

#include "JSObjectInlines.h"

#include "JSToWasm.h"

#include "JSWebAssemblyHelpers.h"

#include "JSWebAssemblyInstance.h"

#include "JSWebAssemblyMemory.h"

#include "JSWebAssemblyRuntimeError.h"

#include "LLIntThunks.h"

#include "LinkBuffer.h"

#include "NativeExecutable.h"

#include "ProtoCallFrameInlines.h"

#include "SlotVisitorInlines.h"

#include "StructureCreateInlines.h"

#include "WasmCallee.h"

#include "WasmCallingConvention.h"

#include "WasmContext.h"

#include "WasmFormat.h"

#include "WasmMemory.h"

#include "WasmMemoryInformation.h"

#include "WasmModuleInformation.h"

#include "WasmOperations.h"

#include "WasmTypeDefinitionInlines.h"

namespace JSC {

const ClassInfo WebAssemblyFunction::s_info = { "WebAssemblyFunction"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(WebAssemblyFunction) };

static JSC_DECLARE_HOST_FUNCTION(callWebAssemblyFunction);

JSC_DEFINE_HOST_FUNCTION(callWebAssemblyFunction, (JSGlobalObject* globalObject, CallFrame* callFrame))

{

VM& vm = globalObject->vm();

WebAssemblyFunction* wasmFunction = uncheckedDowncast<WebAssemblyFunction>(callFrame->jsCallee());

if (wasmFunction->instance()->taintedness() >= SourceTaintedOrigin::IndirectlyTainted)

vm.setMightBeExecutingTaintedCode();

// Note: we specifically use the WebAssemblyFunction as the callee to begin with in the ProtoCallFrame.

// The reason for this is that calling into the IPInt may stack overflow, and the stack overflow

// handler might read the global object from the callee.

// For wasm, we setup |codeBlock| and |this| differently.

// |codeBlock| : JS entry wrapper expects a JSWebAssemblyInstance* as the |codeBlock| value argument.

ProtoCallFrame protoCallFrame;

protoCallFrame.init(nullptr, globalObject, wasmFunction, JSValue(), nullptr, callFrame->argumentCountIncludingThis(), std::bit_cast<EncodedJSValue*>(callFrame->addressOfArgumentsStart()));

protoCallFrame.setWasmInstance(wasmFunction->instance());

return vmEntryToWasm(wasmFunction->jsToWasm(ArityCheckMode::MustCheckArity).taggedPtr(), &vm, &protoCallFrame);

}

WebAssemblyFunction* WebAssemblyFunction::create(VM& vm, JSGlobalObject* globalObject, Structure* structure, unsigned length, const String& name, JSWebAssemblyInstance* instance, Wasm::IPIntCallee& wasmCallee, Wasm::WasmToWasmImportableFunction::LoadLocation wasmToWasmEntrypointLoadLocation, Ref<const Wasm::RTT>&& rtt)

{

NativeExecutable* base = vm.getHostFunction(callWebAssemblyFunction, ImplementationVisibility::Public, WasmFunctionIntrinsic, callHostFunctionAsConstructor, nullptr, 0, String());

// Since ClosureCall uses this executable as an identity for Wasm CallIC thunk, we need to make it diversified.

NativeExecutable* executable = NativeExecutable::create(vm, base->generatedJITCodeForCall(), callWebAssemblyFunction, base->generatedJITCodeForConstruct(), callHostFunctionAsConstructor, ImplementationVisibility::Public, length, name);

WebAssemblyFunction* function = new (NotNull, allocateCell<WebAssemblyFunction>(vm)) WebAssemblyFunction(vm, executable, globalObject, structure, instance, wasmCallee, wasmToWasmEntrypointLoadLocation, WTF::move(rtt));

function->finishCreation(vm);

// The LLInt and JIT JS->Wasm entry trampolines read m_boxedJSToWasmCallee and

// m_frameSize directly from this object, and are entered from many paths that

// bypass callWebAssemblyFunction. Ensure they are populated before any such entry.

// FIXME: Move this to those places so the JSToWasmCallee is materialized lazily.

function->ensureJSToWasmCallee();

return function;

}

Structure* WebAssemblyFunction::createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)

{

ASSERT(globalObject);

return Structure::create(vm, globalObject, prototype, TypeInfo(JSFunctionType, StructureFlags), info());

}

WebAssemblyFunction::WebAssemblyFunction(VM& vm, NativeExecutable* executable, JSGlobalObject* globalObject, Structure* structure, JSWebAssemblyInstance* instance, Wasm::IPIntCallee& wasmCallee, Wasm::WasmToWasmImportableFunction::LoadLocation wasmToWasmEntrypointLoadLocation, Ref<const Wasm::RTT>&& rtt)

}

Wasm::JSToWasmCallee& WebAssemblyFunction::ensureJSToWasmCallee()

{

// WebAssemblyFunction is tied to a single thread; CalleeGroup's cache has its own lock.

if (m_boxedJSToWasmCallee) [[likely]]

return *m_boxedJSToWasmCallee;

auto* wasmCallee = uncheckedDowncast<Wasm::Callee>(importableFunction().boxedCallee.asNativeCallee());

auto& callee = instance()->calleeGroup()->ensureJSToWasmCallee(instance()->moduleInformation(), wasmCallee->index());

m_frameSize = callee.frameSize();

m_boxedJSToWasmCallee = &callee;

return callee;

}

template<typename Visitor>

void WebAssemblyFunction::visitChildrenImpl(JSCell* cell, Visitor& visitor)

}

DEFINE_VISIT_CHILDREN(WebAssemblyFunction);

void WebAssemblyFunction::destroy(JSCell* cell)

{

static_cast<WebAssemblyFunction*>(cell)->WebAssemblyFunction::~WebAssemblyFunction();

}

} // namespace JSC

#endif // ENABLE(WEBASSEMBLY)