#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 "StructureInlines.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"

#include <wtf/StackPointer.h>

#include <wtf/SystemTracing.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 = jsCast<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::JSToWasmCallee& jsToWasm, Wasm::IPIntCallee& wasmCallee, Wasm::WasmToWasmImportableFunction::LoadLocation wasmToWasmEntrypointLoadLocation, Wasm::TypeIndex typeIndex, Ref<const Wasm::RTT>&& rtt)

{

NativeExecutable* base = vm.getHostFunction(callWebAssemblyFunction, ImplementationVisibility::Public, WasmFunctionIntrinsic, callHostFunctionAsConstructor, nullptr, 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, name);

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

function->finishCreation(vm, executable, length, name);

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::JSToWasmCallee& jsToWasm, Wasm::IPIntCallee& wasmCallee, Wasm::WasmToWasmImportableFunction::LoadLocation wasmToWasmEntrypointLoadLocation, Wasm::TypeIndex typeIndex, Ref<const Wasm::RTT>&& rtt)

}

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)