COMMIT_MESSAGE

1memory-wast-js

2

Source/JavaScriptCore/ChangeLog

2017-03-17  JF Bastien  <jfbastien@apple.com>

        WebAssembly: spec-tests/memory.wast.js fails in debug

        https://bugs.webkit.org/show_bug.cgi?id=169794

        Reviewed by NOBODY (OOPS!).

        The failure was due to empty memories (with maximum size 0). Those

        only occur in tests and in code that's trying to trip us. This

        patch adds memory mode "none" which represents no memory. It can

        work with either bounds checked or signaling code because it never

        contains loads and stores.

        The spec tests which were failing did the following:

            > (module (memory (data)) (func (export "memsize") (result i32) (current_memory)))

            > (assert_return (invoke "memsize") (i32.const 0))

            > (module (memory (data "")) (func (export "memsize") (result i32) (current_memory)))

            > (assert_return (invoke "memsize") (i32.const 0))

            > (module (memory (data "x")) (func (export "memsize") (result i32) (current_memory)))

            > (assert_return (invoke "memsize") (i32.const 1))

        * wasm/WasmB3IRGenerator.cpp:

        (JSC::Wasm::B3IRGenerator::memoryKind):

        * wasm/WasmMemory.cpp:

        (JSC::Wasm::tryGetFastMemory):

        (JSC::Wasm::releaseFastMemory):

        (JSC::Wasm::Memory::Memory):

        (JSC::Wasm::Memory::createImpl):

        (JSC::Wasm::Memory::create):

        (JSC::Wasm::Memory::grow):

        (JSC::Wasm::Memory::makeString):

        * wasm/WasmMemory.h:

        * wasm/WasmMemoryInformation.cpp:

        (JSC::Wasm::MemoryInformation::MemoryInformation):

        * wasm/js/JSWebAssemblyCodeBlock.cpp:

        (JSC::JSWebAssemblyCodeBlock::isSafeToRun):

        * wasm/js/JSWebAssemblyModule.cpp:

        (JSC::JSWebAssemblyModule::codeBlock):

        (JSC::JSWebAssemblyModule::finishCreation):

        * wasm/js/JSWebAssemblyModule.h:

        (JSC::JSWebAssemblyModule::codeBlock):

        (JSC::JSWebAssemblyModule::codeBlockFor):

        * wasm/js/WebAssemblyInstanceConstructor.cpp:

        (JSC::WebAssemblyInstanceConstructor::createInstance):

        * wasm/js/WebAssemblyMemoryConstructor.cpp:

        (JSC::constructJSWebAssemblyMemory):

2017-03-17  Michael Saboff  <msaboff@apple.com>

        Use USE_INTERNAL_SDK to compute ENABLE_FAST_JIT_PERMISSIONS instead of HAVE_INTERNAL_SDK

Source/JavaScriptCore/wasm/JSWebAssemblyCodeBlock.h

@@public:

    typedef JSCell Base;

    static const unsigned StructureFlags = Base::StructureFlags | StructureIsImmortal;

47 static JSWebAssemblyCodeBlock* create(VM& vm, JSWebAssemblyModule* owner, Bag<CallLinkInfo>&& callLinkInfos, Vector<Wasm::WasmExitStubs>&& exitStubs, Wasm::Memory::Mode mode, unsigned calleeCount)

47 static JSWebAssemblyCodeBlock* create(VM& vm, JSWebAssemblyModule* owner, Bag<CallLinkInfo>&& callLinkInfos, Vector<Wasm::WasmExitStubs>&& exitStubs, Wasm::MemoryMode mode, unsigned calleeCount)

    {

        auto* result = new (NotNull, allocateCell<JSWebAssemblyCodeBlock>(vm.heap, allocationSize(calleeCount))) JSWebAssemblyCodeBlock(vm, owner, std::forward<Bag<CallLinkInfo>>(callLinkInfos), std::forward<Vector<Wasm::WasmExitStubs>>(exitStubs), mode, calleeCount);

        result->finishCreation(vm);

@@public:

    }

    unsigned functionImportCount() const { return m_wasmExitStubs.size(); }

60 Wasm::Memory::Mode mode() const { return m_mode; }

60 Wasm::MemoryMode mode() const { return m_mode; }

    JSWebAssemblyModule* module() const { return m_module.get(); }

    bool isSafeToRun(JSWebAssemblyMemory*);

@@public:

    }

private:

104 JSWebAssemblyCodeBlock(VM&, JSWebAssemblyModule*, Bag<CallLinkInfo>&&, Vector<Wasm::WasmExitStubs>&&, Wasm::Memory::Mode, unsigned calleeCount);

104 JSWebAssemblyCodeBlock(VM&, JSWebAssemblyModule*, Bag<CallLinkInfo>&&, Vector<Wasm::WasmExitStubs>&&, Wasm::MemoryMode, unsigned calleeCount);

    DECLARE_EXPORT_INFO;

    static const bool needsDestruction = true;

    static void destroy(JSCell*);

@@private:

    UnconditionalFinalizer m_unconditionalFinalizer;

    Bag<CallLinkInfo> m_callLinkInfos;

    Vector<Wasm::WasmExitStubs> m_wasmExitStubs;

128 Wasm::Memory::Mode m_mode;

128 Wasm::MemoryMode m_mode;

    unsigned m_calleeCount;

};

Source/JavaScriptCore/wasm/WasmB3IRGenerator.cpp

11/*

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

@@auto B3IRGenerator::setGlobal(uint32_t index, ExpressionType value) -> PartialRe

inline Value* B3IRGenerator::emitCheckAndPreparePointer(ExpressionType pointer, uint32_t offset, uint32_t sizeOfOperation)

{

    ASSERT(m_memoryBaseGPR);

461 if (m_info.memory.mode() == Memory::Mode::BoundsChecking) {

461 if (m_info.memory.mode() == MemoryMode::BoundsChecking) {

        ASSERT(m_memorySizeGPR);

        ASSERT(sizeOfOperation + offset > offset);

        m_currentBlock->appendNew<WasmBoundsCheckValue>(m_proc, Origin(), pointer, m_memorySizeGPR, sizeOfOperation + offset - 1);

@@inline uint32_t sizeOfLoadOp(LoadOpType op)

inline B3::Kind B3IRGenerator::memoryKind(B3::Opcode memoryOp)

{

497 if (m_info.memory.mode() == Memory::Signaling)

497 if (m_info.memory.mode() == MemoryMode::Signaling)

        return trapping(memoryOp);

    return memoryOp;

}

Source/JavaScriptCore/wasm/WasmMemory.cpp

11/*

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

@@inline bool mmapBytes(size_t bytes, void*& memory)

    return true;

}

const char* makeString(MemoryMode mode)

{

    switch (mode) {

    case MemoryMode::BoundsChecking: return "BoundsChecking";

    case MemoryMode::Signaling: return "Signaling";

    case MemoryMode::NumberOfMemoryModes: break;

    }

    RELEASE_ASSERT_NOT_REACHED();

    return "";

}

5970// We use this as a heuristic to guess what mode a memory import will be. Most of the time we expect users to

6071// allocate the memory they are going to pass to all their modules right before compilation.

61 static Memory::Mode lastAllocatedMemoryMode { Memory::Mode::Signaling };

72static MemoryMode lastAllocatedMemoryMode { MemoryMode::Signaling };

6273

63 Memory::Mode Memory::lastAllocatedMode()

74MemoryMode Memory::lastAllocatedMode()

{

    return lastAllocatedMemoryMode;

}

@@const HashSet<void*>& viewActiveFastMemories(const AbstractLocker& locker)

    return activeFastMemories(locker);

}

88 inline bool tryGetFastMemory(VM& vm, void*& memory, size_t& mappedCapacity, Memory::Mode& mode)

99inline bool tryGetFastMemory(VM& vm, void*& memory, size_t& mappedCapacity, MemoryMode& mode)

{

    // We might GC here so we should be holding the API lock.

    // FIXME: We should be able to syncronously trigger the GC from another thread.

@@inline bool tryGetFastMemory(VM& vm, void*& memory, size_t& mappedCapacity, Memo

            auto result = activeFastMemories(locker).add(memory);

            ASSERT_UNUSED(result, result.isNewEntry);

            mappedCapacity = fastMemoryMappedBytes;

109 mode = Memory::Signaling;

120 mode = MemoryMode::Signaling;

            return true;

        }

        return false;

@@inline bool tryGetFastMemory(VM& vm, void*& memory, size_t& mappedCapacity, Memo

    if (mmapBytes(fastMemoryMappedBytes, memory)) {

        mappedCapacity = fastMemoryMappedBytes;

128 mode = Memory::Signaling;

139 mode = MemoryMode::Signaling;

        LockHolder locker(memoryLock);

        allocatedFastMemories++;

        auto result = activeFastMemories(locker).add(memory);

@@inline bool tryGetFastMemory(VM& vm, void*& memory, size_t& mappedCapacity, Memo

    return memory;

}

137 inline void releaseFastMemory(void*& memory, size_t writableSize, size_t mappedCapacity, Memory::Mode mode)

148inline void releaseFastMemory(void*& memory, size_t writableSize, size_t mappedCapacity, MemoryMode mode)

138149{

139 if (mode != Memory::Signaling || !memory)

150 if (mode != MemoryMode::Signaling || !memory)

        return;

    RELEASE_ASSERT(memory && mappedCapacity == fastMemoryMappedBytes);

@@inline void releaseFastMemory(void*& memory, size_t writableSize, size_t mappedC

Memory::Memory(PageCount initial, PageCount maximum)

    : m_initial(initial)

    , m_maximum(maximum)

171 , m_mode(MemoryMode::BoundsChecking)

160172{

161173 ASSERT(!initial.bytes());

174 dataLogLnIf(verbose, "Memory::Memory allocating ", *this);

162175}

163176

164 Memory::Memory(void* memory, PageCount initial, PageCount maximum, size_t mappedCapacity, Mode mode)

177Memory::Memory(void* memory, PageCount initial, PageCount maximum, size_t mappedCapacity, MemoryMode mode)

    : m_memory(memory)

    , m_size(initial.bytes())

    , m_initial(initial)

@@Memory::Memory(void* memory, PageCount initial, PageCount maximum, size_t mapped

    dataLogLnIf(verbose, "Memory::Memory allocating ", *this);

}

175 RefPtr<Memory> Memory::createImpl(VM& vm, PageCount initial, PageCount maximum, std::optional<Mode> requiredMode)

188RefPtr<Memory> Memory::createImpl(VM& vm, PageCount initial, PageCount maximum, std::optional<MemoryMode> requiredMode)

{

    RELEASE_ASSERT(!maximum || maximum >= initial); // This should be guaranteed by our caller.

179 Mode mode = requiredMode ? *requiredMode : BoundsChecking;

192 MemoryMode mode = requiredMode ? *requiredMode : MemoryMode::BoundsChecking;

    const size_t size = initial.bytes();

    size_t mappedCapacity = maximum ? maximum.bytes() : PageCount::max().bytes();

    void* memory = nullptr;

    auto makeEmptyMemory = [&] () -> RefPtr<Memory> {

185 if (mode == Signaling)

198 if (mode == MemoryMode::Signaling)

186199 return nullptr;

187200

188 lastAllocatedMemoryMode = BoundsChecking;

201 lastAllocatedMemoryMode = MemoryMode::BoundsChecking;

        return adoptRef(new Memory(initial, maximum));

    };

@@RefPtr<Memory> Memory::createImpl(VM& vm, PageCount initial, PageCount maximum,

        return makeEmptyMemory();

    }

199 bool canUseFastMemory = !requiredMode || requiredMode == Signaling;

212 bool canUseFastMemory = !requiredMode || requiredMode == MemoryMode::Signaling;

200213 if (!canUseFastMemory || !tryGetFastMemory(vm, memory, mappedCapacity, mode)) {

201 if (mode == Signaling)

214 if (mode == MemoryMode::Signaling)

            return nullptr;

        if (Options::simulateWebAssemblyLowMemory() ? true : !mmapBytes(mappedCapacity, memory)) {

@@RefPtr<Memory> Memory::createImpl(VM& vm, PageCount initial, PageCount maximum,

    ASSERT(memory && size <= mappedCapacity);

    if (mprotect(memory, size, PROT_READ | PROT_WRITE)) {

235 // FIXME: should this ever occur? https://bugs.webkit.org/show_bug.cgi?id=169890

        dataLogLnIf(verbose, "Memory::create mprotect failed");

        releaseFastMemory(memory, 0, mappedCapacity, mode);

        if (memory) {

@@RefPtr<Memory> Memory::createImpl(VM& vm, PageCount initial, PageCount maximum,

        }

        return nullptr;

    }

230

244

    lastAllocatedMemoryMode = mode;

    dataLogLnIf(verbose, "Memory::create mmap succeeded");

    return adoptRef(new Memory(memory, initial, maximum, mappedCapacity, mode));

}

236 RefPtr<Memory> Memory::create(VM& vm, PageCount initial, PageCount maximum, std::optional<Mode> mode)

250RefPtr<Memory> Memory::create(VM& vm, PageCount initial, PageCount maximum, std::optional<MemoryMode> mode)

{

    RELEASE_ASSERT(!maximum || maximum >= initial); // This should be guaranteed by our caller.

    RefPtr<Memory> result = createImpl(vm, initial, maximum, mode);

    if (result) {

241 if (result->mode() == Signaling)

255 if (result->mode() == MemoryMode::Signaling)

            RELEASE_ASSERT(result->m_mappedCapacity == fastMemoryMappedBytes);

        if (mode)

            ASSERT(*mode == result->mode());

245 ASSERT(lastAllocatedMemoryMode == result->mode());

    }

    return result;

}

@@bool Memory::grow(PageCount newSize)

    size_t desiredSize = newSize.bytes();

    switch (mode()) {

    case MemoryMode::BoundsChecking:

        RELEASE_ASSERT(maximum().bytes() != 0);

        break;

    case MemoryMode::Signaling:

        // Signaling memory must have been pre-allocated virtually.

        RELEASE_ASSERT(m_memory);

        break;

    case MemoryMode::NumberOfMemoryModes:

        RELEASE_ASSERT_NOT_REACHED();

    }

271296 if (m_memory && desiredSize <= m_mappedCapacity) {

272297 if (mprotect(static_cast<uint8_t*>(m_memory) + m_size, static_cast<size_t>(desiredSize - m_size), PROT_READ | PROT_WRITE)) {

298 // FIXME: should this ever occur? https://bugs.webkit.org/show_bug.cgi?id=169890

            dataLogLnIf(verbose, "Memory::grow in-place failed ", *this);

            return false;

        }

@@bool Memory::grow(PageCount newSize)

        return true;

    }

282 ASSERT(mode() != Signaling);

    // Signaling memory can't grow past its already-mapped size.

    RELEASE_ASSERT(mode() != MemoryMode::Signaling);

283311 // Otherwise, let's try to make some new memory.

312 // FIXME: It would be nice if we had a VM tag for wasm memory. https://bugs.webkit.org/show_bug.cgi?id=163600

    void* newMemory = mmap(nullptr, desiredSize, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);

    if (newMemory == MAP_FAILED)

        return false;

@@void Memory::dump(PrintStream& out) const

    out.print("Memory at ", RawPointer(m_memory), ", size ", m_size, "B capacity ", m_mappedCapacity, "B, initial ", m_initial, " maximum ", m_maximum, " mode ", makeString(m_mode));

}

const char* Memory::makeString(Mode mode) const

{

    switch (mode) {

    case Mode::BoundsChecking: return "BoundsChecking";

    case Mode::Signaling: return "Signaling";

    case Mode::NumberOfModes: break;

    }

    RELEASE_ASSERT_NOT_REACHED();

    return "";

}

} // namespace JSC

} // namespace Wasm

Source/JavaScriptCore/wasm/WasmMemory.h

11/*

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

@@class VM;

namespace Wasm {

// FIXME: We should support other modes. see: https://bugs.webkit.org/show_bug.cgi?id=162693

enum class MemoryMode {

    BoundsChecking,

    Signaling,

    NumberOfMemoryModes

};

static constexpr size_t NumberOfMemoryModes = static_cast<size_t>(MemoryMode::NumberOfMemoryModes);

const char* makeString(MemoryMode);

class Memory : public RefCounted<Memory> {

    WTF_MAKE_NONCOPYABLE(Memory);

    WTF_MAKE_FAST_ALLOCATED;

public:

    void dump(WTF::PrintStream&) const;

    // FIXME: We should support other modes. see: https://bugs.webkit.org/show_bug.cgi?id=162693

    enum Mode {

        BoundsChecking,

        Signaling,

        NumberOfModes

    };

    const char* makeString(Mode) const;

6162 explicit operator bool() const { return !!m_memory; }

6263

63 static RefPtr<Memory> create(VM&, PageCount initial, PageCount maximum, std::optional<Mode> requiredMode = std::nullopt);

64 static RefPtr<Memory> create(VM&, PageCount initial, PageCount maximum, std::optional<MemoryMode> requiredMode = std::nullopt);

    Memory() = default;

    ~Memory();

@@public:

    PageCount initial() const { return m_initial; }

    PageCount maximum() const { return m_maximum; }

75 static Mode lastAllocatedMode();

76 Mode mode() const { return m_mode; }

76 static MemoryMode lastAllocatedMode();

77 MemoryMode mode() const { return m_mode; }

    // grow() should only be called from the JSWebAssemblyMemory object since that object needs to update internal

    // pointers with the current base and size.

@@public:

    void check() {  ASSERT(!deletionHasBegun()); }

private:

84 static RefPtr<Memory> createImpl(VM&, PageCount initial, PageCount maximum, std::optional<Mode> requiredMode = std::nullopt);

85 Memory(void* memory, PageCount initial, PageCount maximum, size_t mappedCapacity, Mode);

85 static RefPtr<Memory> createImpl(VM&, PageCount initial, PageCount maximum, std::optional<MemoryMode> requiredMode = std::nullopt);

86 Memory(void* memory, PageCount initial, PageCount maximum, size_t mappedCapacity, MemoryMode);

    Memory(PageCount initial, PageCount maximum);

    // FIXME: we should move these to the instance to avoid a load on instance->instance calls.

@@private:

    PageCount m_initial;

    PageCount m_maximum;

    size_t m_mappedCapacity { 0 };

94 Mode m_mode { Mode::BoundsChecking };

95 MemoryMode m_mode { MemoryMode::BoundsChecking };

};

static_assert(sizeof(uint64_t) == sizeof(size_t), "We rely on allowing the maximum size of Memory we map to be 2^33 which is larger than fits in a 32-bit integer that we'd pass to mprotect if this didn't hold.");

Source/JavaScriptCore/wasm/WasmMemoryInformation.cpp

11/*

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

@@PinnedRegisterInfo::PinnedRegisterInfo(Vector<PinnedSizeRegisterInfo>&& sizeRegi

{

}

77 MemoryInformation::MemoryInformation(VM& vm, PageCount initial, PageCount maximum, std::optional<Memory::Mode> recompileMode, bool isImport)

77MemoryInformation::MemoryInformation(VM& vm, PageCount initial, PageCount maximum, std::optional<MemoryMode> recompileMode, bool isImport)

    : m_initial(initial)

    , m_maximum(maximum)

    , m_isImport(isImport)

@@MemoryInformation::MemoryInformation(VM& vm, PageCount initial, PageCount maximu

    if (!recompileMode) {

        if (!isImport) {

88 m_reservedMemory = Memory::create(vm, initial, maximum, Memory::Signaling);

            if (maximum && maximum.bytes() == 0) {

                m_reservedMemory = Memory::create(vm, initial, maximum, MemoryMode::BoundsChecking);

                RELEASE_ASSERT(m_reservedMemory);

                RELEASE_ASSERT(m_reservedMemory->maximum());

                RELEASE_ASSERT(m_reservedMemory->maximum().bytes() == 0);

                m_mode = m_reservedMemory->mode();

                return;

            }

            m_reservedMemory = Memory::create(vm, initial, maximum, MemoryMode::Signaling);

            if (m_reservedMemory) {

                ASSERT(!!*m_reservedMemory);

                m_mode = m_reservedMemory->mode();

Source/JavaScriptCore/wasm/WasmMemoryInformation.h

@@public:

        ASSERT(!*this);

    }

57 MemoryInformation(VM&, PageCount initial, PageCount maximum, std::optional<Memory::Mode>, bool isImport);

57 MemoryInformation(VM&, PageCount initial, PageCount maximum, std::optional<MemoryMode>, bool isImport);

    PageCount initial() const { return m_initial; }

    PageCount maximum() const { return m_maximum; }

    bool hasReservedMemory() const { return m_reservedMemory; }

    RefPtr<Memory> takeReservedMemory() { ASSERT(hasReservedMemory()); return m_reservedMemory.release(); }

63 Memory::Mode mode() const { return m_mode; }

63 MemoryMode mode() const { return m_mode; }

    bool isImport() const { return m_isImport; }

    explicit operator bool() const { return !!m_initial; }

@@private:

    RefPtr<Memory> m_reservedMemory;

    PageCount m_initial { };

    PageCount m_maximum { };

72 Memory::Mode m_mode { Memory::Mode::BoundsChecking };

72 MemoryMode m_mode { MemoryMode::BoundsChecking };

    bool m_isImport { false };

};

Source/JavaScriptCore/wasm/WasmModuleParser.h

@@struct ModuleParserResult {

class ModuleParser : public Parser<ModuleParserResult> {

public:

47 ModuleParser(VM* vm, const uint8_t* sourceBuffer, size_t sourceLength, std::optional<Memory::Mode> mode)

47 ModuleParser(VM* vm, const uint8_t* sourceBuffer, size_t sourceLength, std::optional<MemoryMode> mode)

        : Parser(vm, sourceBuffer, sourceLength)

        , m_mode(mode)

    {

@@private:

    PartialResult WARN_UNUSED_RETURN parseInitExpr(uint8_t&, uint64_t&, Type& initExprType);

    ModuleParserResult m_result;

69 std::optional<Memory::Mode> m_mode { std::nullopt };

69 std::optional<MemoryMode> m_mode { std::nullopt };

    bool m_hasTable { false };

};

Source/JavaScriptCore/wasm/WasmPlan.cpp

@@Plan::Plan(VM* vm, const uint8_t* source, size_t sourceLength)

{

}

66 bool Plan::parseAndValidateModule(std::optional<Memory::Mode> recompileMode)

66bool Plan::parseAndValidateModule(std::optional<MemoryMode> recompileMode)

{

    MonotonicTime startTime;

    if (verbose || Options::reportCompileTimes())

@@bool Plan::parseAndValidateModule(std::optional<Memory::Mode> recompileMode)

// The reason this is OK is that we guarantee that the main thread doesn't continue until all threads

// that could touch its stack are done executing.

SUPPRESS_ASAN 

114 void Plan::run(std::optional<Memory::Mode> recompileMode)

114void Plan::run(std::optional<MemoryMode> recompileMode)

{

    if (!parseAndValidateModule(recompileMode))

        return;

Source/JavaScriptCore/wasm/WasmPlan.h

@@public:

    JS_EXPORT_PRIVATE Plan(VM*, const uint8_t*, size_t);

    JS_EXPORT_PRIVATE ~Plan();

52 bool parseAndValidateModule(std::optional<Memory::Mode> = std::nullopt);

52 bool parseAndValidateModule(std::optional<MemoryMode> = std::nullopt);

5353

54 JS_EXPORT_PRIVATE void run(std::optional<Memory::Mode> = std::nullopt);

54 JS_EXPORT_PRIVATE void run(std::optional<MemoryMode> = std::nullopt);

    JS_EXPORT_PRIVATE void initializeCallees(JSGlobalObject*, std::function<void(unsigned, JSWebAssemblyCallee*, JSWebAssemblyCallee*)>);

@@public:

        return WTFMove(m_wasmExitStubs);

    }

95 Memory::Mode mode() const { return m_moduleInformation->memory.mode(); }

95 MemoryMode mode() const { return m_moduleInformation->memory.mode(); }

private:

    std::unique_ptr<ModuleInformation> m_moduleInformation;

Source/JavaScriptCore/wasm/js/JSWebAssemblyCodeBlock.cpp

@@namespace JSC {

const ClassInfo JSWebAssemblyCodeBlock::s_info = { "WebAssemblyCodeBlock", nullptr, 0, CREATE_METHOD_TABLE(JSWebAssemblyCodeBlock) };

39 JSWebAssemblyCodeBlock::JSWebAssemblyCodeBlock(VM& vm, JSWebAssemblyModule* owner, Bag<CallLinkInfo>&& callLinkInfos, Vector<Wasm::WasmExitStubs>&& wasmExitStubs, Wasm::Memory::Mode mode, unsigned calleeCount)

39JSWebAssemblyCodeBlock::JSWebAssemblyCodeBlock(VM& vm, JSWebAssemblyModule* owner, Bag<CallLinkInfo>&& callLinkInfos, Vector<Wasm::WasmExitStubs>&& wasmExitStubs, Wasm::MemoryMode mode, unsigned calleeCount)

    : Base(vm, vm.webAssemblyCodeBlockStructure.get())

    , m_callLinkInfos(WTFMove(callLinkInfos))

    , m_wasmExitStubs(WTFMove(wasmExitStubs))

@@void JSWebAssemblyCodeBlock::destroy(JSCell* cell)

bool JSWebAssemblyCodeBlock::isSafeToRun(JSWebAssemblyMemory* memory)

{

    if (mode() == Wasm::Memory::Signaling)

        return memory->memory().mode() == mode();

    return true;

    Wasm::MemoryMode codeMode = mode();

    Wasm::MemoryMode memoryMode = memory->memory().mode();

    switch (codeMode) {

    case Wasm::MemoryMode::BoundsChecking:

        return true;

    case Wasm::MemoryMode::Signaling:

        // Code being in Signaling mode means that it performs no bounds checks.

        // Its memory, even if empty, absolutely must also be in Signaling mode

        // because the page protection detect out-of-bounds accesses.

        return memoryMode == Wasm::MemoryMode::Signaling;

    case Wasm::MemoryMode::NumberOfMemoryModes:

        break;

    }

    RELEASE_ASSERT_NOT_REACHED();

    return false;

}

void JSWebAssemblyCodeBlock::visitChildren(JSCell* cell, SlotVisitor& visitor)

Source/JavaScriptCore/wasm/js/JSWebAssemblyInstance.h

@@public:

    JSWebAssemblyMemory* memory() { return m_memory.get(); }

    // Calling this might trigger a recompile.

    void setMemory(VM&, ExecState*, JSWebAssemblyMemory*);

82 Wasm::Memory::Mode memoryMode() { return memory()->memory().mode(); }

82 Wasm::MemoryMode memoryMode() { return memory()->memory().mode(); }

    JSWebAssemblyTable* table() { return m_table.get(); }

    void setTable(VM& vm, JSWebAssemblyTable* table) { m_table.set(vm, this, table); }

Source/JavaScriptCore/wasm/js/JSWebAssemblyModule.cpp

11/*

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

@@namespace JSC {

const ClassInfo JSWebAssemblyModule::s_info = { "WebAssembly.Module", &Base::s_info, nullptr, CREATE_METHOD_TABLE(JSWebAssemblyModule) };

45 JSWebAssemblyCodeBlock* JSWebAssemblyModule::buildCodeBlock(VM& vm, ExecState* exec, Wasm::Plan& plan, std::optional<Wasm::Memory::Mode> mode)

45JSWebAssemblyCodeBlock* JSWebAssemblyModule::buildCodeBlock(VM& vm, ExecState* exec, Wasm::Plan& plan, std::optional<Wasm::MemoryMode> mode)

{

    auto scope = DECLARE_THROW_SCOPE(vm);

    // On failure, a new WebAssembly.CompileError is thrown.

@@JSWebAssemblyModule::JSWebAssemblyModule(VM& vm, Structure* structure)

JSWebAssemblyCodeBlock* JSWebAssemblyModule::codeBlock(VM& vm, ExecState* exec, JSWebAssemblyMemory* memory)

{

88 Wasm::Memory::Mode mode = memory->memory().mode();

88 Wasm::MemoryMode mode = memory->memory().mode();

8989

90 for (unsigned i = 0; i < Wasm::~~Memory::~~NumberOfModes; ++i) {

90 for (unsigned i = 0; i < Wasm::NumberOfMemoryModes; ++i) {

        if (m_codeBlocks[i] && m_codeBlocks[i]->isSafeToRun(memory))

            return m_codeBlocks[i].get();

    }

95 ASSERT(!m_codeBlocks[mode]);

95 ASSERT(!codeBlockFor(mode));

    auto scope = DECLARE_THROW_SCOPE(vm);

    // We don't have a code block for this mode, we need to recompile...

    Wasm::Plan plan(&vm, static_cast<uint8_t*>(m_sourceBuffer->data()), m_sourceBuffer->byteLength());

@@JSWebAssemblyCodeBlock* JSWebAssemblyModule::codeBlock(VM& vm, ExecState* exec,

    }

    ASSERT(mode == codeBlock->mode());

110 m_codeBlocks[mode].set(vm, this, codeBlock);

110 codeBlockFor(mode).set(vm, this, codeBlock);

    return codeBlock;

}

@@void JSWebAssemblyModule::finishCreation(VM& vm, ExecState* exec, uint8_t* sourc

    m_sourceBuffer = ArrayBuffer::create(source, byteSize);

    m_moduleInformation = plan.takeModuleInformation();

    m_exportSymbolTable.set(vm, this, exportSymbolTable);

135 m_codeBlocks[codeBlock->mode()].set(vm, this, codeBlock);

135 codeBlockFor(codeBlock->mode()).set(vm, this, codeBlock);

}

void JSWebAssemblyModule::destroy(JSCell* cell)

@@void JSWebAssemblyModule::visitChildren(JSCell* cell, SlotVisitor& visitor)

    Base::visitChildren(thisObject, visitor);

    visitor.append(thisObject->m_exportSymbolTable);

150 for (unsigned i = 0; i < Wasm::~~Memory::~~NumberOfModes; ++i)

150 for (unsigned i = 0; i < Wasm::NumberOfMemoryModes; ++i)

        visitor.append(thisObject->m_codeBlocks[i]);

}

Source/JavaScriptCore/wasm/js/JSWebAssemblyModule.h

@@public:

    }

    // Returns the code block that this module was originally compiled expecting to use. This won't need to recompile.

65 JSWebAssemblyCodeBlock* codeBlock() { return m_codeBlocks[m_moduleInformation->memory.mode()].get(); }

65 JSWebAssemblyCodeBlock* codeBlock() { return codeBlockFor(m_moduleInformation->memory.mode()).get(); }

    // Returns the appropriate code block for the given memory, possibly triggering a recompile.

    JSWebAssemblyCodeBlock* codeBlock(VM&, ExecState*, JSWebAssemblyMemory*);

private:

70 JSWebAssemblyCodeBlock* buildCodeBlock(VM&, ExecState*, Wasm::Plan&, std::optional<Wasm::Memory::Mode> mode = std::nullopt);

70 WriteBarrier<JSWebAssemblyCodeBlock>& codeBlockFor(Wasm::MemoryMode mode) { return m_codeBlocks[static_cast<size_t>(mode)]; }

71 JSWebAssemblyCodeBlock* buildCodeBlock(VM&, ExecState*, Wasm::Plan&, std::optional<Wasm::MemoryMode> mode = std::nullopt);

    JSWebAssemblyModule(VM&, Structure*);

    void finishCreation(VM&, ExecState*, uint8_t* source, size_t byteSize);

@@private:

    RefPtr<ArrayBuffer> m_sourceBuffer;

    std::unique_ptr<Wasm::ModuleInformation> m_moduleInformation;

    WriteBarrier<SymbolTable> m_exportSymbolTable;

80 WriteBarrier<JSWebAssemblyCodeBlock> m_codeBlocks[Wasm::~~Memory::~~NumberOfModes];

81 WriteBarrier<JSWebAssemblyCodeBlock> m_codeBlocks[Wasm::NumberOfMemoryModes];

};

} // namespace JSC

Source/JavaScriptCore/wasm/js/WebAssemblyInstanceConstructor.cpp

11/*

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

Source/JavaScriptCore/wasm/js/WebAssemblyMemoryConstructor.cpp

11/*

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions