WebAssembly: implement data section
authorjfbastien@apple.com <jfbastien@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 10 Dec 2016 07:08:31 +0000 (07:08 +0000)
committerjfbastien@apple.com <jfbastien@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 10 Dec 2016 07:08:31 +0000 (07:08 +0000)
https://bugs.webkit.org/show_bug.cgi?id=165696

Reviewed by Keith Miller.

As specified in https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md#data-section
Note that some of the interesting corner cases are ill-defined by the spec: https://github.com/WebAssembly/design/issues/897

JSTests:

* wasm/Builder.js: create a data section from JavaScript
* wasm/Builder_WebAssemblyBinary.js: assemble the data section into the proper binary encoding
(const.emitters.Data):
* wasm/js-api/test_Data.js: Added.
(DataSection):
(DataSectionOffTheEnd):
(DataSectionPartlyOffTheEnd):
(DataSectionEmptyOffTheEnd):
(DataSectionSeenByStart):
* wasm/self-test/test_BuilderJSON.js: make sure the JSON structure is fine (this sanity checks before going to binary)

Source/JavaScriptCore:

* wasm/WasmFormat.h: segments are what represent sections of memory to initialize (similar to ELF's non-zero intializer data / rodata)
(JSC::Wasm::Segment::make):
(JSC::Wasm::Segment::destroy):
(JSC::Wasm::Segment::byte):
(JSC::Wasm::Segment::makePtr):
* wasm/WasmModuleParser.cpp: parse the data section, and prevent a few overflows if a user passes in UINT_MAX (the loops would overflow)
(JSC::Wasm::ModuleParser::parseType):
(JSC::Wasm::ModuleParser::parseImport):
(JSC::Wasm::ModuleParser::parseFunction):
(JSC::Wasm::ModuleParser::parseExport):
(JSC::Wasm::ModuleParser::parseCode):
(JSC::Wasm::ModuleParser::parseData):
* wasm/js/WebAssemblyModuleRecord.cpp:
(JSC::WebAssemblyModuleRecord::evaluate): the only sensible time to initialize the data section is after linking, but before calling start, I test for this but the spec isn't clear it's correct yet

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@209651 268f45cc-cd09-0410-ab3c-d52691b4dbfc

JSTests/ChangeLog
JSTests/wasm/Builder.js
JSTests/wasm/Builder_WebAssemblyBinary.js
JSTests/wasm/js-api/test_Data.js [new file with mode: 0644]
JSTests/wasm/self-test/test_BuilderJSON.js
Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/wasm/WasmFormat.h
Source/JavaScriptCore/wasm/WasmModuleParser.cpp
Source/JavaScriptCore/wasm/js/WebAssemblyModuleRecord.cpp

index 4266d3e..7571685 100644 (file)
@@ -1,5 +1,26 @@
 2016-12-09  JF Bastien  <jfbastien@apple.com>
 
+        WebAssembly: implement data section
+        https://bugs.webkit.org/show_bug.cgi?id=165696
+
+        Reviewed by Keith Miller.
+
+        As specified in https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md#data-section
+        Note that some of the interesting corner cases are ill-defined by the spec: https://github.com/WebAssembly/design/issues/897
+
+        * wasm/Builder.js: create a data section from JavaScript
+        * wasm/Builder_WebAssemblyBinary.js: assemble the data section into the proper binary encoding
+        (const.emitters.Data):
+        * wasm/js-api/test_Data.js: Added.
+        (DataSection):
+        (DataSectionOffTheEnd):
+        (DataSectionPartlyOffTheEnd):
+        (DataSectionEmptyOffTheEnd):
+        (DataSectionSeenByStart):
+        * wasm/self-test/test_BuilderJSON.js: make sure the JSON structure is fine (this sanity checks before going to binary)
+
+2016-12-09  JF Bastien  <jfbastien@apple.com>
+
         WebAssembly JS API: implement start function
         https://bugs.webkit.org/show_bug.cgi?id=165150
 
index a1f80b7..5951417 100644 (file)
@@ -523,8 +523,38 @@ export default class Builder {
                 break;
 
             case "Data":
-                // FIXME implement data https://bugs.webkit.org/show_bug.cgi?id=161709
-                this[section] = () => { throw new Error(`Unimplemented: section type "${section}"`); };
+                this[section] = function() {
+                    const s = this._addSection(section);
+                    const dataBuilder = {
+                        End: () => this,
+                        Segment: data => {
+                            assert.isArray(data);
+                            for (const datum of data) {
+                                assert.isNumber(datum);
+                                assert.ge(datum, 0);
+                                assert.le(datum, 0xff);
+                            }
+                            s.data.push({ data: data, index: 0, offset: 0 });
+                            let thisSegment = s.data[s.data.length - 1];
+                            const segmentBuilder = {
+                                End: () => dataBuilder,
+                                Index: index => {
+                                    assert.eq(index, 0); // Linear memory index must be zero in MVP.
+                                    thisSegment.index = index;
+                                    return segmentBuilder;
+                                },
+                                Offset: offset => {
+                                    // FIXME allow complex init_expr here. https://bugs.webkit.org/show_bug.cgi?id=165700
+                                    assert.isNumber(offset);
+                                    thisSegment.offset = offset;
+                                    return segmentBuilder;
+                                },
+                            };
+                            return segmentBuilder;
+                        },
+                    };
+                    return dataBuilder;
+                };
                 break;
 
             default:
index a856b4d..d3ab5e5 100644 (file)
@@ -156,7 +156,20 @@ const emitters = {
         }
     },
 
-    Data: (section, bin) => { throw new Error(`Not yet implemented`); },
+    Data: (section, bin) => {
+        put(bin, "varuint32", section.data.length);
+        for (const datum of section.data) {
+            put(bin, "varuint32", datum.index);
+            // FIXME allow complex init_expr here. https://bugs.webkit.org/show_bug.cgi?id=165700
+            // For now we only handle i32.const as offset.
+            put(bin, "uint8", WASM.description.opcode["i32.const"].value);
+            put(bin, WASM.description.opcode["i32.const"].immediate[0].type, datum.offset);
+            put(bin, "uint8", WASM.description.opcode["end"].value);
+            put(bin, "varuint32", datum.data.length);
+            for (const byte of datum.data)
+                put(bin, "uint8", byte);
+        }
+    },
 };
 
 export const Binary = (preamble, sections) => {
diff --git a/JSTests/wasm/js-api/test_Data.js b/JSTests/wasm/js-api/test_Data.js
new file mode 100644 (file)
index 0000000..80b5e79
--- /dev/null
@@ -0,0 +1,135 @@
+import * as assert from '../assert.js';
+import Builder from '../Builder.js';
+
+const memSizeInPages = 1;
+const pageSizeInBytes = 64 * 1024;
+const memoryDescription = { initial: memSizeInPages, maximum: memSizeInPages };
+
+// FIXME Some corner cases are ill-specified: https://github.com/WebAssembly/design/issues/897
+
+(function DataSection() {
+    const builder = (new Builder())
+        .Type().End()
+        .Import().Memory("imp", "memory", memoryDescription).End()
+        .Data()
+          .Segment([0xff, 0x2a]).Offset(4).End()
+          .Segment([0xde, 0xad, 0xbe, 0xef]).Offset(24).End()
+          .Segment([0xca, 0xfe]).Offset(25).End() // Overwrite.
+          .Segment([]).Offset(4).End() // Empty.
+        .End();
+    const bin = builder.WebAssembly().get();
+    const module = new WebAssembly.Module(bin);
+    const memory = new WebAssembly.Memory(memoryDescription);
+    const instance = new WebAssembly.Instance(module, { imp: { memory: memory } });
+    const buffer = new Uint8Array(memory.buffer);
+    for (let idx = 0; idx < memSizeInPages * pageSizeInBytes; ++idx) {
+        const value = buffer[idx];
+        switch (idx) {
+        case 4: assert.eq(value, 0xff); break;
+        case 5: assert.eq(value, 0x2a); break;
+        case 24: assert.eq(value, 0xde); break;
+        case 25: assert.eq(value, 0xca); break;
+        case 26: assert.eq(value, 0xfe); break;
+        case 27: assert.eq(value, 0xef); break;
+        default: assert.eq(value, 0x00); break;
+        }
+    }
+})();
+
+(function DataSectionOffTheEnd() {
+    const builder = (new Builder())
+        .Type().End()
+        .Import().Memory("imp", "memory", memoryDescription).End()
+        .Data()
+          .Segment([0xff]).Offset(memSizeInPages * pageSizeInBytes).End()
+        .End();
+    const bin = builder.WebAssembly().get();
+    const module = new WebAssembly.Module(bin);
+    const memory = new WebAssembly.Memory(memoryDescription);
+    assert.throws(() => new WebAssembly.Instance(module, { imp: { memory: memory } }), RangeError, `Data segment initializes memory out of range`);
+    const buffer = new Uint8Array(memory.buffer);
+    for (let idx = 0; idx < memSizeInPages * pageSizeInBytes; ++idx) {
+        const value = buffer[idx];
+        assert.eq(value, 0x00);
+    }
+})();
+
+(function DataSectionPartlyOffTheEnd() {
+    const builder = (new Builder())
+        .Type().End()
+        .Import().Memory("imp", "memory", memoryDescription).End()
+        .Data()
+          .Segment([0xff, 0xff]).Offset(memSizeInPages * pageSizeInBytes - 1).End()
+        .End();
+    const bin = builder.WebAssembly().get();
+    const module = new WebAssembly.Module(bin);
+    const memory = new WebAssembly.Memory(memoryDescription);
+    assert.throws(() => new WebAssembly.Instance(module, { imp: { memory: memory } }), RangeError, `Data segment initializes memory out of range`);
+    const buffer = new Uint8Array(memory.buffer);
+    for (let idx = 0; idx < memSizeInPages * pageSizeInBytes; ++idx) {
+        const value = buffer[idx];
+        assert.eq(value, 0x00);
+    }
+})();
+
+(function DataSectionEmptyOffTheEnd() {
+    const builder = (new Builder())
+        .Type().End()
+        .Import().Memory("imp", "memory", memoryDescription).End()
+        .Data()
+          .Segment([]).Offset(memSizeInPages * pageSizeInBytes).End()
+        .End();
+    const bin = builder.WebAssembly().get();
+    const module = new WebAssembly.Module(bin);
+    const memory = new WebAssembly.Memory(memoryDescription);
+    const instance = new WebAssembly.Instance(module, { imp: { memory: memory } });
+    const buffer = new Uint8Array(memory.buffer);
+    for (let idx = 0; idx < memSizeInPages * pageSizeInBytes; ++idx) {
+        const value = buffer[idx];
+        assert.eq(value, 0x00);
+    }
+})();
+
+(function DataSectionSeenByStart() {
+    const offset = 1024;
+    const builder = (new Builder())
+        .Type().End()
+        .Import()
+            .Memory("imp", "memory", memoryDescription)
+            .Function("imp", "func", { params: ["i32"] })
+        .End()
+        .Function().End()
+        .Start("foo").End()
+        .Code()
+            .Function("foo", { params: [] })
+                .I32Const(offset)
+                .I32Load8U(2, 0)
+                .Call(0) // Calls func((i8.load(offset), align=2, offset=0). This should observe 0xff as set by the data section.
+            .End()
+        .End()
+        .Data()
+          .Segment([0xff]).Offset(offset).End()
+        .End();
+    const bin = builder.WebAssembly().get();
+    const module = new WebAssembly.Module(bin);
+    const memory = new WebAssembly.Memory(memoryDescription);
+    let value = 0;
+    const setter = v => value = v;
+    const instance = new WebAssembly.Instance(
+        module,
+        {
+            imp: {
+                memory: memory,
+                func: setter
+            }
+        });
+    assert.eq(value, 0xff);
+    const buffer = new Uint8Array(memory.buffer);
+    for (let idx = 0; idx < memSizeInPages * pageSizeInBytes; ++idx) {
+        const value = buffer[idx];
+        if (idx == offset)
+            assert.eq(value, 0xff);
+        else
+            assert.eq(value, 0x00);
+    }
+})();
index b3929ec..d1c0ca6 100644 (file)
@@ -619,6 +619,7 @@ const assertOpThrows = (opFn, message) => {
     assert.eq(j.section[1].data[0].code.length, 6);
     assert.eq(j.section[1].data[0].code[3].name, "select");
 })();
+// FIXME test type mismatch with select. https://bugs.webkit.org/show_bug.cgi?id=163267
 
 (function MemoryImport() {
     const builder = (new Builder())
@@ -639,4 +640,27 @@ const assertOpThrows = (opFn, message) => {
     assert.eq(json.section[1].data[0].memoryDescription.maximum, 31);
 })();
 
-// FIXME test type mismatch with select. https://bugs.webkit.org/show_bug.cgi?id=163267
+(function DataSection() {
+    const builder = (new Builder())
+        .Memory().InitialMaxPages(64, 64).End()
+        .Data()
+          .Segment([0xff, 0x2a]).Offset(4).End()
+          .Segment([0xde, 0xad, 0xbe, 0xef]).Index(0).Offset(24).End()
+        .End();
+    const json = JSON.parse(builder.json());
+    assert.eq(json.section.length, 2);
+    assert.eq(json.section[1].name, "Data");
+    assert.eq(json.section[1].data.length, 2);
+    assert.eq(json.section[1].data[0].index, 0);
+    assert.eq(json.section[1].data[0].offset, 4);
+    assert.eq(json.section[1].data[0].data.length, 2);
+    assert.eq(json.section[1].data[0].data[0], 0xff);
+    assert.eq(json.section[1].data[0].data[1], 0x2a);
+    assert.eq(json.section[1].data[1].index, 0);
+    assert.eq(json.section[1].data[1].offset, 24);
+    assert.eq(json.section[1].data[1].data.length, 4);
+    assert.eq(json.section[1].data[1].data[0], 0xde);
+    assert.eq(json.section[1].data[1].data[1], 0xad);
+    assert.eq(json.section[1].data[1].data[2], 0xbe);
+    assert.eq(json.section[1].data[1].data[3], 0xef);
+})();
index 918d253..0190610 100644 (file)
@@ -1,3 +1,28 @@
+2016-12-09  JF Bastien  <jfbastien@apple.com>
+
+        WebAssembly: implement data section
+        https://bugs.webkit.org/show_bug.cgi?id=165696
+
+        Reviewed by Keith Miller.
+
+        As specified in https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md#data-section
+        Note that some of the interesting corner cases are ill-defined by the spec: https://github.com/WebAssembly/design/issues/897
+
+        * wasm/WasmFormat.h: segments are what represent sections of memory to initialize (similar to ELF's non-zero intializer data / rodata)
+        (JSC::Wasm::Segment::make):
+        (JSC::Wasm::Segment::destroy):
+        (JSC::Wasm::Segment::byte):
+        (JSC::Wasm::Segment::makePtr):
+        * wasm/WasmModuleParser.cpp: parse the data section, and prevent a few overflows if a user passes in UINT_MAX (the loops would overflow)
+        (JSC::Wasm::ModuleParser::parseType):
+        (JSC::Wasm::ModuleParser::parseImport):
+        (JSC::Wasm::ModuleParser::parseFunction):
+        (JSC::Wasm::ModuleParser::parseExport):
+        (JSC::Wasm::ModuleParser::parseCode):
+        (JSC::Wasm::ModuleParser::parseData):
+        * wasm/js/WebAssemblyModuleRecord.cpp:
+        (JSC::WebAssemblyModuleRecord::evaluate): the only sensible time to initialize the data section is after linking, but before calling start, I test for this but the spec isn't clear it's correct yet
+
 2016-12-09  Karim H  <karim@karhm.com>
 
         It is okay to turn undefined into null because we are producing values for a
index f043519..4f4cfb1 100644 (file)
@@ -35,6 +35,8 @@
 #include "WasmMemoryInformation.h"
 #include "WasmOps.h"
 #include "WasmPageCount.h"
+#include <memory>
+#include <wtf/FastMalloc.h>
 #include <wtf/Optional.h>
 #include <wtf/Vector.h>
 
@@ -114,6 +116,35 @@ struct FunctionLocationInBinary {
     size_t end;
 };
 
+struct Segment {
+    uint32_t offset;
+    uint32_t sizeInBytes;
+    // Bytes are allocated at the end.
+    static Segment* make(uint32_t offset, uint32_t sizeInBytes)
+    {
+        auto allocated = tryFastCalloc(sizeof(Segment) + sizeInBytes, 1);
+        Segment* segment;
+        if (!allocated.getValue(segment))
+            return nullptr;
+        segment->offset = offset;
+        segment->sizeInBytes = sizeInBytes;
+        return segment;
+    }
+    static void destroy(Segment *segment)
+    {
+        fastFree(segment);
+    }
+    uint8_t& byte(uint32_t pos)
+    {
+        ASSERT(pos < sizeInBytes);
+        return *reinterpret_cast<uint8_t*>(reinterpret_cast<char*>(this) + sizeof(offset) + sizeof(sizeInBytes) + pos);
+    }
+    typedef std::unique_ptr<Segment, decltype(&Segment::destroy)> Ptr;
+    static Ptr makePtr(Segment* segment)
+    {
+        return Ptr(segment, &Segment::destroy);
+    }
+};
 
 struct ModuleInformation {
     Vector<Signature> signatures;
@@ -125,6 +156,7 @@ struct ModuleInformation {
     MemoryInformation memory;
     Vector<Export> exports;
     std::optional<uint32_t> startFunctionIndexSpace;
+    Vector<Segment::Ptr> data;
 
     ~ModuleInformation();
 };
index 9db08c8..4e5d00d 100644 (file)
@@ -157,12 +157,12 @@ bool ModuleParser::parse()
 bool ModuleParser::parseType()
 {
     uint32_t count;
-    if (!parseVarUInt32(count))
+    if (!parseVarUInt32(count)
+        || count == std::numeric_limits<uint32_t>::max()
+        || !m_module->signatures.tryReserveCapacity(count))
         return false;
     if (verbose)
-        dataLogLn("count: ", count);
-    if (!m_module->signatures.tryReserveCapacity(count))
-        return false;
+        dataLogLn("  count: ", count);
 
     for (uint32_t i = 0; i < count; ++i) {
         int8_t type;
@@ -175,17 +175,15 @@ bool ModuleParser::parseType()
             dataLogLn("Got function type.");
 
         uint32_t argumentCount;
-        if (!parseVarUInt32(argumentCount))
-            return false;
-
-        if (verbose)
-            dataLogLn("argumentCount: ", argumentCount);
-
         Vector<Type> argumentTypes;
-        if (!argumentTypes.tryReserveCapacity(argumentCount))
+        if (!parseVarUInt32(argumentCount)
+            || argumentCount == std::numeric_limits<uint32_t>::max()
+            || !argumentTypes.tryReserveCapacity(argumentCount))
             return false;
+        if (verbose)
+            dataLogLn("  argument count: ", argumentCount);
 
-        for (unsigned i = 0; i != argumentCount; ++i) {
+        for (unsigned i = 0; i < argumentCount; ++i) {
             Type argumentType;
             if (!parseResultType(argumentType))
                 return false;
@@ -216,14 +214,14 @@ bool ModuleParser::parseType()
 bool ModuleParser::parseImport()
 {
     uint32_t importCount;
-    if (!parseVarUInt32(importCount))
-        return false;
-    if (!m_module->imports.tryReserveCapacity(importCount) // FIXME this over-allocates when we fix the FIXMEs below.
+    if (!parseVarUInt32(importCount)
+        || importCount == std::numeric_limits<uint32_t>::max()
+        || !m_module->imports.tryReserveCapacity(importCount) // FIXME this over-allocates when we fix the FIXMEs below.
         || !m_module->importFunctions.tryReserveCapacity(importCount) // FIXME this over-allocates when we fix the FIXMEs below.
         || !m_functionIndexSpace.tryReserveCapacity(importCount)) // FIXME this over-allocates when we fix the FIXMEs below. We'll allocate some more here when we know how many functions to expect.
         return false;
 
-    for (uint32_t importNumber = 0; importNumber != importCount; ++importNumber) {
+    for (uint32_t importNumber = 0; importNumber < importCount; ++importNumber) {
         Import imp;
         uint32_t moduleLen;
         uint32_t fieldLen;
@@ -278,12 +276,13 @@ bool ModuleParser::parseFunction()
 {
     uint32_t count;
     if (!parseVarUInt32(count)
+        || count == std::numeric_limits<uint32_t>::max()
         || !m_module->internalFunctionSignatures.tryReserveCapacity(count)
         || !m_functionLocationInBinary.tryReserveCapacity(count)
         || !m_functionIndexSpace.tryReserveCapacity(m_functionIndexSpace.size() + count))
         return false;
 
-    for (uint32_t i = 0; i != count; ++i) {
+    for (uint32_t i = 0; i < count; ++i) {
         uint32_t typeNumber;
         if (!parseVarUInt32(typeNumber)
             || typeNumber >= m_module->signatures.size())
@@ -374,10 +373,11 @@ bool ModuleParser::parseExport()
 {
     uint32_t exportCount;
     if (!parseVarUInt32(exportCount)
+        || exportCount == std::numeric_limits<uint32_t>::max()
         || !m_module->exports.tryReserveCapacity(exportCount))
         return false;
 
-    for (uint32_t exportNumber = 0; exportNumber != exportCount; ++exportNumber) {
+    for (uint32_t exportNumber = 0; exportNumber < exportCount; ++exportNumber) {
         Export exp;
         uint32_t fieldLen;
         String fieldString;
@@ -385,8 +385,10 @@ bool ModuleParser::parseExport()
             || !consumeUTF8String(fieldString, fieldLen))
             return false;
         exp.field = Identifier::fromString(m_vm, fieldString);
+
         if (!parseExternalKind(exp.kind))
             return false;
+
         switch (exp.kind) {
         case External::Function: {
             if (!parseVarUInt32(exp.functionIndex)
@@ -440,10 +442,11 @@ bool ModuleParser::parseCode()
 {
     uint32_t count;
     if (!parseVarUInt32(count)
+        || count == std::numeric_limits<uint32_t>::max()
         || count != m_functionLocationInBinary.size())
         return false;
 
-    for (uint32_t i = 0; i != count; ++i) {
+    for (uint32_t i = 0; i < count; ++i) {
         uint32_t functionSize;
         if (!parseVarUInt32(functionSize)
             || functionSize > length()
@@ -460,8 +463,56 @@ bool ModuleParser::parseCode()
 
 bool ModuleParser::parseData()
 {
-    // FIXME https://bugs.webkit.org/show_bug.cgi?id=161709
-    RELEASE_ASSERT_NOT_REACHED();
+    uint32_t segmentCount;
+    if (!parseVarUInt32(segmentCount)
+        || segmentCount == std::numeric_limits<uint32_t>::max()
+        || !m_module->data.tryReserveCapacity(segmentCount))
+        return false;
+    if (verbose)
+        dataLogLn("  segments: ", segmentCount);
+
+    for (uint32_t segmentNumber = 0; segmentNumber < segmentCount; ++segmentNumber) {
+        if (verbose)
+            dataLogLn("  segment #", segmentNumber);
+        uint32_t index;
+        uint8_t opcode;
+        uint32_t offset;
+        uint8_t endOpcode;
+        uint32_t dataByteLength;
+        if (!parseVarUInt32(index)
+            || index)
+            return false;
+
+        // FIXME allow complex init_expr here. https://bugs.webkit.org/show_bug.cgi?id=165700
+        // For now we only handle i32.const as offset.
+        if (!parseUInt8(opcode)
+            || opcode != Wasm::I32Const
+            || !parseVarUInt32(offset)
+            || !parseUInt8(endOpcode)
+            || endOpcode != Wasm::End)
+            return false;
+        if (verbose)
+            dataLogLn("    offset: ", offset);
+
+        if (!parseVarUInt32(dataByteLength)
+            || dataByteLength == std::numeric_limits<uint32_t>::max())
+            return false;
+        if (verbose)
+            dataLogLn("    data bytes: ", dataByteLength);
+
+        Segment* segment = Segment::make(offset, dataByteLength);
+        if (!segment)
+            return false;
+        m_module->data.uncheckedAppend(Segment::makePtr(segment));
+        for (uint32_t dataByte = 0; dataByte < dataByteLength; ++dataByte) {
+            uint8_t byte;
+            if (!parseUInt8(byte))
+                return false;
+            segment->byte(dataByte) = byte;
+            if (verbose)
+                dataLogLn("    [", dataByte, "] = ", segment->byte(dataByte));
+        }
+    }
     return true;
 }
 
index 569fbc6..67d5e22 100644 (file)
@@ -187,9 +187,27 @@ void WebAssemblyModuleRecord::link(ExecState* state, JSWebAssemblyInstance* inst
 
 JSValue WebAssemblyModuleRecord::evaluate(ExecState* state)
 {
+    VM& vm = state->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    if (JSWebAssemblyMemory* jsMemory = m_instance->memory()) {
+        uint8_t* memory = reinterpret_cast<uint8_t*>(jsMemory->memory()->memory());
+        auto sizeInBytes = jsMemory->memory()->size();
+        if (memory) {
+            const Vector<Wasm::Segment::Ptr>& data = m_instance->module()->moduleInformation().data;
+            for (auto& segment : data) {
+                if (segment->sizeInBytes) {
+                    if (sizeInBytes < segment->sizeInBytes
+                        || segment->offset > sizeInBytes
+                        || segment->offset > sizeInBytes - segment->sizeInBytes)
+                        return throwException(state, scope, createRangeError(state, ASCIILiteral("Data segment initializes memory out of range")));
+                    memcpy(memory + segment->offset, &segment->byte(0), segment->sizeInBytes);
+                }
+            }
+        }
+    }
+
     if (WebAssemblyFunction* startFunction = m_startFunction.get()) {
-        VM& vm = state->vm();
-        auto scope = DECLARE_THROW_SCOPE(vm);
         ProtoCallFrame protoCallFrame;
         protoCallFrame.init(nullptr, startFunction, JSValue(), 1, nullptr);
         startFunction->call(vm, &protoCallFrame);