#pragma once
#if ENABLE(WEBASSEMBLY)
#include "WasmCodeBlock.h"
#include "WasmEmbedder.h"
#include "WasmMemory.h"
#include <wtf/Expected.h>
#include <wtf/Lock.h>
#include <wtf/SharedTask.h>
#include <wtf/ThreadSafeRefCounted.h>
namespace JSC { namespace Wasm {
class LLIntPlan;
struct Context;
struct ModuleInformation;
using SignatureIndex = uint64_t;
class Module : public ThreadSafeRefCounted<Module> {
public:
using ValidationResult = Expected<RefPtr<Module>, String>;
typedef void CallbackType(ValidationResult&&);
using AsyncValidationCallback = RefPtr<SharedTask<CallbackType>>;
static ValidationResult validateSync(Context*, Vector<uint8_t>&& source);
static void validateAsync(Context*, Vector<uint8_t>&& source, Module::AsyncValidationCallback&&);
static Ref<Module> create(LLIntPlan& plan)
{
return adoptRef(*new Module(plan));
}
Wasm::SignatureIndex signatureIndexFromFunctionIndexSpace(unsigned functionIndexSpace) const;
const Wasm::ModuleInformation& moduleInformation() const { return m_moduleInformation.get(); }
Ref<CodeBlock> compileSync(Context*, MemoryMode);
void compileAsync(Context*, MemoryMode, CodeBlock::AsyncCompilationCallback&&);
JS_EXPORT_PRIVATE ~Module();
CodeBlock* codeBlockFor(MemoryMode mode) { return m_codeBlocks[static_cast<uint8_t>(mode)].get(); }
private:
Ref<CodeBlock> getOrCreateCodeBlock(Context*, MemoryMode);
Module(LLIntPlan&);
Ref<ModuleInformation> m_moduleInformation;
RefPtr<CodeBlock> m_codeBlocks[Wasm::NumberOfMemoryModes];
RefPtr<LLIntCallees> m_llintCallees;
MacroAssemblerCodeRef<B3CompilationPtrTag> m_llintEntryThunks;
Lock m_lock;
};
} }
#endif // ENABLE(WEBASSEMBLY)