AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity
cc237d872b
v8/test/unittests/wasm/streaming-decoder-unittest.cc

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

640 lines
22 KiB
C++
Raw Normal View History

[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "test/unittests/test-utils.h"
#include "src/objects-inl.h"
#include "src/wasm/module-decoder.h"
#include "src/wasm/streaming-decoder.h"
#include "src/objects/descriptor-array.h"
#include "src/objects/dictionary.h"
#include "test/common/wasm/wasm-macro-gen.h"
namespace v8 {
namespace internal {
namespace wasm {
[wasm] Streaming compilation for WebAssembly. In this CL I implement streaming compilation for WebAssembly, as described in the design doc I have sent out already. In this implementation the decoding of sections other than the code section is done immediately on the foreground thread. Eventually all decoding should happen in the background. I think it is acceptable to do the decoding on the foreground thread for now because I have finished it already, and decoding in the background would add even more complexity to this CL. Bug:v8:6785 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I285e1e5e1a5a243113c92571b25ee9bae551d0ed Reviewed-on: https://chromium-review.googlesource.com/631721 Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48022}
2017-09-14 17:34:15 +00:00
class MockStreamingProcessor : public StreamingProcessor {
public:
bool ProcessModuleHeader(Vector<const uint8_t> bytes,
uint32_t offset) override {
// TODO(ahaas): Share code with the module-decoder.
Decoder decoder(bytes.begin(), bytes.end());
uint32_t magic_word = decoder.consume_u32("wasm magic");
if (decoder.failed() || magic_word != kWasmMagic) {
ok_ = false;
return false;
}
uint32_t magic_version = decoder.consume_u32("wasm version");
if (decoder.failed() || magic_version != kWasmVersion) {
ok_ = false;
return false;
}
return true;
}
// Process all sections but the code section.
bool ProcessSection(SectionCode section_code, Vector<const uint8_t> bytes,
uint32_t offset) override {
++num_sections_;
return true;
}
bool ProcessCodeSectionHeader(size_t num_functions,
uint32_t offset) override {
return true;
}
// Process a function body.
bool ProcessFunctionBody(Vector<const uint8_t> bytes,
uint32_t offset) override {
++num_functions_;
return true;
}
void OnFinishedChunk() override {}
// Finish the processing of the stream.
void OnFinishedStream(std::unique_ptr<uint8_t[]> bytes,
size_t length) override {
received_bytes_ = std::move(bytes);
length_ = length;
}
// Report an error detected in the StreamingDecoder.
void OnError(DecodeResult result) override { ok_ = false; }
void OnAbort() override {}
size_t num_sections() const { return num_sections_; }
size_t num_functions() const { return num_functions_; }
bool ok() const { return ok_; }
Vector<const uint8_t> received_bytes() {
return Vector<const uint8_t>(received_bytes_.get(), length_);
}
private:
size_t num_sections_ = 0;
size_t num_functions_ = 0;
bool ok_ = true;
std::unique_ptr<uint8_t[]> received_bytes_;
size_t length_;
};
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
class WasmStreamingDecoderTest : public ::testing::Test {
public:
[wasm] Streaming compilation for WebAssembly. In this CL I implement streaming compilation for WebAssembly, as described in the design doc I have sent out already. In this implementation the decoding of sections other than the code section is done immediately on the foreground thread. Eventually all decoding should happen in the background. I think it is acceptable to do the decoding on the foreground thread for now because I have finished it already, and decoding in the background would add even more complexity to this CL. Bug:v8:6785 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I285e1e5e1a5a243113c92571b25ee9bae551d0ed Reviewed-on: https://chromium-review.googlesource.com/631721 Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48022}
2017-09-14 17:34:15 +00:00
void ExpectVerifies(Vector<const uint8_t> data, size_t expected_sections,
size_t expected_functions) {
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
for (int split = 0; split <= data.length(); ++split) {
[wasm] Streaming compilation for WebAssembly. In this CL I implement streaming compilation for WebAssembly, as described in the design doc I have sent out already. In this implementation the decoding of sections other than the code section is done immediately on the foreground thread. Eventually all decoding should happen in the background. I think it is acceptable to do the decoding on the foreground thread for now because I have finished it already, and decoding in the background would add even more complexity to this CL. Bug:v8:6785 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I285e1e5e1a5a243113c92571b25ee9bae551d0ed Reviewed-on: https://chromium-review.googlesource.com/631721 Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48022}
2017-09-14 17:34:15 +00:00
// Use a unique_ptr so that the StreamingDecoder can own the processor.
std::unique_ptr<MockStreamingProcessor> p(new MockStreamingProcessor());
MockStreamingProcessor* processor = p.get();
StreamingDecoder stream(std::move(p));
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
stream.OnBytesReceived(data.SubVector(0, split));
stream.OnBytesReceived(data.SubVector(split, data.length()));
[wasm] Streaming compilation for WebAssembly. In this CL I implement streaming compilation for WebAssembly, as described in the design doc I have sent out already. In this implementation the decoding of sections other than the code section is done immediately on the foreground thread. Eventually all decoding should happen in the background. I think it is acceptable to do the decoding on the foreground thread for now because I have finished it already, and decoding in the background would add even more complexity to this CL. Bug:v8:6785 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I285e1e5e1a5a243113c92571b25ee9bae551d0ed Reviewed-on: https://chromium-review.googlesource.com/631721 Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48022}
2017-09-14 17:34:15 +00:00
stream.Finish();
EXPECT_TRUE(processor->ok());
EXPECT_EQ(expected_sections, processor->num_sections());
EXPECT_EQ(expected_functions, processor->num_functions());
EXPECT_EQ(data, processor->received_bytes());
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
}
}
void ExpectFailure(Vector<const uint8_t> data) {
for (int split = 0; split <= data.length(); ++split) {
[wasm] Streaming compilation for WebAssembly. In this CL I implement streaming compilation for WebAssembly, as described in the design doc I have sent out already. In this implementation the decoding of sections other than the code section is done immediately on the foreground thread. Eventually all decoding should happen in the background. I think it is acceptable to do the decoding on the foreground thread for now because I have finished it already, and decoding in the background would add even more complexity to this CL. Bug:v8:6785 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I285e1e5e1a5a243113c92571b25ee9bae551d0ed Reviewed-on: https://chromium-review.googlesource.com/631721 Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48022}
2017-09-14 17:34:15 +00:00
std::unique_ptr<MockStreamingProcessor> p(new MockStreamingProcessor());
MockStreamingProcessor* processor = p.get();
StreamingDecoder stream(std::move(p));
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
stream.OnBytesReceived(data.SubVector(0, split));
stream.OnBytesReceived(data.SubVector(split, data.length()));
[wasm] Streaming compilation for WebAssembly. In this CL I implement streaming compilation for WebAssembly, as described in the design doc I have sent out already. In this implementation the decoding of sections other than the code section is done immediately on the foreground thread. Eventually all decoding should happen in the background. I think it is acceptable to do the decoding on the foreground thread for now because I have finished it already, and decoding in the background would add even more complexity to this CL. Bug:v8:6785 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I285e1e5e1a5a243113c92571b25ee9bae551d0ed Reviewed-on: https://chromium-review.googlesource.com/631721 Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48022}
2017-09-14 17:34:15 +00:00
stream.Finish();
EXPECT_FALSE(processor->ok());
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
}
}
};
TEST_F(WasmStreamingDecoderTest, EmptyStream) {
[wasm] Streaming compilation for WebAssembly. In this CL I implement streaming compilation for WebAssembly, as described in the design doc I have sent out already. In this implementation the decoding of sections other than the code section is done immediately on the foreground thread. Eventually all decoding should happen in the background. I think it is acceptable to do the decoding on the foreground thread for now because I have finished it already, and decoding in the background would add even more complexity to this CL. Bug:v8:6785 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I285e1e5e1a5a243113c92571b25ee9bae551d0ed Reviewed-on: https://chromium-review.googlesource.com/631721 Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48022}
2017-09-14 17:34:15 +00:00
std::unique_ptr<MockStreamingProcessor> p(new MockStreamingProcessor());
MockStreamingProcessor* processor = p.get();
StreamingDecoder stream(std::move(p));
stream.Finish();
EXPECT_FALSE(processor->ok());
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
}
TEST_F(WasmStreamingDecoderTest, IncompleteModuleHeader) {
const uint8_t data[] = {U32_LE(kWasmMagic), U32_LE(kWasmVersion)};
{
[wasm] Streaming compilation for WebAssembly. In this CL I implement streaming compilation for WebAssembly, as described in the design doc I have sent out already. In this implementation the decoding of sections other than the code section is done immediately on the foreground thread. Eventually all decoding should happen in the background. I think it is acceptable to do the decoding on the foreground thread for now because I have finished it already, and decoding in the background would add even more complexity to this CL. Bug:v8:6785 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I285e1e5e1a5a243113c92571b25ee9bae551d0ed Reviewed-on: https://chromium-review.googlesource.com/631721 Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48022}
2017-09-14 17:34:15 +00:00
std::unique_ptr<MockStreamingProcessor> p(new MockStreamingProcessor());
MockStreamingProcessor* processor = p.get();
StreamingDecoder stream(std::move(p));
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
stream.OnBytesReceived(Vector<const uint8_t>(data, 1));
[wasm] Streaming compilation for WebAssembly. In this CL I implement streaming compilation for WebAssembly, as described in the design doc I have sent out already. In this implementation the decoding of sections other than the code section is done immediately on the foreground thread. Eventually all decoding should happen in the background. I think it is acceptable to do the decoding on the foreground thread for now because I have finished it already, and decoding in the background would add even more complexity to this CL. Bug:v8:6785 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I285e1e5e1a5a243113c92571b25ee9bae551d0ed Reviewed-on: https://chromium-review.googlesource.com/631721 Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48022}
2017-09-14 17:34:15 +00:00
stream.Finish();
EXPECT_FALSE(processor->ok());
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
}
for (int length = 1; length < static_cast<int>(arraysize(data)); ++length) {
ExpectFailure(Vector<const uint8_t>(data, length));
}
}
TEST_F(WasmStreamingDecoderTest, MagicAndVersion) {
const uint8_t data[] = {U32_LE(kWasmMagic), U32_LE(kWasmVersion)};
[wasm] Streaming compilation for WebAssembly. In this CL I implement streaming compilation for WebAssembly, as described in the design doc I have sent out already. In this implementation the decoding of sections other than the code section is done immediately on the foreground thread. Eventually all decoding should happen in the background. I think it is acceptable to do the decoding on the foreground thread for now because I have finished it already, and decoding in the background would add even more complexity to this CL. Bug:v8:6785 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I285e1e5e1a5a243113c92571b25ee9bae551d0ed Reviewed-on: https://chromium-review.googlesource.com/631721 Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48022}
2017-09-14 17:34:15 +00:00
ExpectVerifies(Vector<const uint8_t>(data, arraysize(data)), 0, 0);
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
}
TEST_F(WasmStreamingDecoderTest, BadMagic) {
for (uint32_t x = 1; x; x <<= 1) {
const uint8_t data[] = {U32_LE(kWasmMagic ^ x), U32_LE(kWasmVersion)};
ExpectFailure(Vector<const uint8_t>(data, arraysize(data)));
}
}
TEST_F(WasmStreamingDecoderTest, BadVersion) {
for (uint32_t x = 1; x; x <<= 1) {
const uint8_t data[] = {U32_LE(kWasmMagic), U32_LE(kWasmVersion ^ x)};
ExpectFailure(Vector<const uint8_t>(data, arraysize(data)));
}
}
TEST_F(WasmStreamingDecoderTest, OneSection) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
0x1, // Section ID
0x6, // Section Length
0x0, // Payload
0x0, // 2
0x0, // 3
0x0, // 4
0x0, // 5
0x0 // 6
};
[wasm] Streaming compilation for WebAssembly. In this CL I implement streaming compilation for WebAssembly, as described in the design doc I have sent out already. In this implementation the decoding of sections other than the code section is done immediately on the foreground thread. Eventually all decoding should happen in the background. I think it is acceptable to do the decoding on the foreground thread for now because I have finished it already, and decoding in the background would add even more complexity to this CL. Bug:v8:6785 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I285e1e5e1a5a243113c92571b25ee9bae551d0ed Reviewed-on: https://chromium-review.googlesource.com/631721 Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48022}
2017-09-14 17:34:15 +00:00
ExpectVerifies(Vector<const uint8_t>(data, arraysize(data)), 1, 0);
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
}
TEST_F(WasmStreamingDecoderTest, OneSection_b) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
0x1, // Section ID
0x86, // Section Length = 6 (LEB)
0x0, // --
0x0, // Payload
0x0, // 2
0x0, // 3
0x0, // 4
0x0, // 5
0x0 // 6
};
[wasm] Streaming compilation for WebAssembly. In this CL I implement streaming compilation for WebAssembly, as described in the design doc I have sent out already. In this implementation the decoding of sections other than the code section is done immediately on the foreground thread. Eventually all decoding should happen in the background. I think it is acceptable to do the decoding on the foreground thread for now because I have finished it already, and decoding in the background would add even more complexity to this CL. Bug:v8:6785 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I285e1e5e1a5a243113c92571b25ee9bae551d0ed Reviewed-on: https://chromium-review.googlesource.com/631721 Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48022}
2017-09-14 17:34:15 +00:00
ExpectVerifies(Vector<const uint8_t>(data, arraysize(data)), 1, 0);
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
}
TEST_F(WasmStreamingDecoderTest, OneShortSection) {
// Short section means that section length + payload is less than 5 bytes,
// which is the maximum size of the length field.
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
0x1, // Section ID
0x2, // Section Length
0x0, // Payload
0x0 // 2
};
[wasm] Streaming compilation for WebAssembly. In this CL I implement streaming compilation for WebAssembly, as described in the design doc I have sent out already. In this implementation the decoding of sections other than the code section is done immediately on the foreground thread. Eventually all decoding should happen in the background. I think it is acceptable to do the decoding on the foreground thread for now because I have finished it already, and decoding in the background would add even more complexity to this CL. Bug:v8:6785 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I285e1e5e1a5a243113c92571b25ee9bae551d0ed Reviewed-on: https://chromium-review.googlesource.com/631721 Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48022}
2017-09-14 17:34:15 +00:00
ExpectVerifies(Vector<const uint8_t>(data, arraysize(data)), 1, 0);
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
}
TEST_F(WasmStreamingDecoderTest, OneShortSection_b) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
0x1, // Section ID
0x82, // Section Length = 2 (LEB)
0x80, // --
0x0, // --
0x0, // Payload
0x0 // 2
};
[wasm] Streaming compilation for WebAssembly. In this CL I implement streaming compilation for WebAssembly, as described in the design doc I have sent out already. In this implementation the decoding of sections other than the code section is done immediately on the foreground thread. Eventually all decoding should happen in the background. I think it is acceptable to do the decoding on the foreground thread for now because I have finished it already, and decoding in the background would add even more complexity to this CL. Bug:v8:6785 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I285e1e5e1a5a243113c92571b25ee9bae551d0ed Reviewed-on: https://chromium-review.googlesource.com/631721 Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48022}
2017-09-14 17:34:15 +00:00
ExpectVerifies(Vector<const uint8_t>(data, arraysize(data)), 1, 0);
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
}
TEST_F(WasmStreamingDecoderTest, OneEmptySection) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
0x1, // Section ID
0x0 // Section Length
};
[wasm] Streaming compilation for WebAssembly. In this CL I implement streaming compilation for WebAssembly, as described in the design doc I have sent out already. In this implementation the decoding of sections other than the code section is done immediately on the foreground thread. Eventually all decoding should happen in the background. I think it is acceptable to do the decoding on the foreground thread for now because I have finished it already, and decoding in the background would add even more complexity to this CL. Bug:v8:6785 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I285e1e5e1a5a243113c92571b25ee9bae551d0ed Reviewed-on: https://chromium-review.googlesource.com/631721 Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48022}
2017-09-14 17:34:15 +00:00
ExpectVerifies(Vector<const uint8_t>(data, arraysize(data)), 1, 0);
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
}
TEST_F(WasmStreamingDecoderTest, OneSectionNotEnoughPayload1) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
0x1, // Section ID
0x6, // Section Length
0x0, // Payload
0x0, // 2
0x0, // 3
0x0, // 4
0x0 // 5
};
ExpectFailure(Vector<const uint8_t>(data, arraysize(data)));
}
TEST_F(WasmStreamingDecoderTest, OneSectionNotEnoughPayload2) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
0x1, // Section ID
0x6, // Section Length
0x0 // Payload
};
ExpectFailure(Vector<const uint8_t>(data, arraysize(data)));
}
TEST_F(WasmStreamingDecoderTest, OneSectionInvalidLength) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
0x1, // Section ID
0x80, // Section Length (0 in LEB)
0x80, // --
0x80, // --
0x80, // --
0x80, // --
};
ExpectFailure(Vector<const uint8_t>(data, arraysize(data)));
}
TEST_F(WasmStreamingDecoderTest, TwoLongSections) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
0x1, // Section ID
0x6, // Section Length
0x0, // Payload
0x0, // 2
0x0, // 3
0x0, // 4
0x0, // 5
0x0, // 6
0x2, // Section ID
0x7, // Section Length
0x0, // Payload
0x0, // 2
0x0, // 3
0x0, // 4
0x0, // 5
0x0, // 6
0x0 // 7
};
[wasm] Streaming compilation for WebAssembly. In this CL I implement streaming compilation for WebAssembly, as described in the design doc I have sent out already. In this implementation the decoding of sections other than the code section is done immediately on the foreground thread. Eventually all decoding should happen in the background. I think it is acceptable to do the decoding on the foreground thread for now because I have finished it already, and decoding in the background would add even more complexity to this CL. Bug:v8:6785 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I285e1e5e1a5a243113c92571b25ee9bae551d0ed Reviewed-on: https://chromium-review.googlesource.com/631721 Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48022}
2017-09-14 17:34:15 +00:00
ExpectVerifies(Vector<const uint8_t>(data, arraysize(data)), 2, 0);
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
}
TEST_F(WasmStreamingDecoderTest, TwoShortSections) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
0x1, // Section ID
0x1, // Section Length
0x0, // Payload
0x2, // Section ID
0x2, // Section Length
0x0, // Payload
0x0, // 2
};
[wasm] Streaming compilation for WebAssembly. In this CL I implement streaming compilation for WebAssembly, as described in the design doc I have sent out already. In this implementation the decoding of sections other than the code section is done immediately on the foreground thread. Eventually all decoding should happen in the background. I think it is acceptable to do the decoding on the foreground thread for now because I have finished it already, and decoding in the background would add even more complexity to this CL. Bug:v8:6785 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I285e1e5e1a5a243113c92571b25ee9bae551d0ed Reviewed-on: https://chromium-review.googlesource.com/631721 Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48022}
2017-09-14 17:34:15 +00:00
ExpectVerifies(Vector<const uint8_t>(data, arraysize(data)), 2, 0);
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
}
TEST_F(WasmStreamingDecoderTest, TwoSectionsShortLong) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
0x1, // Section ID
0x1, // Section Length
0x0, // Payload
0x2, // Section ID
0x7, // Section Length
0x0, // Payload
0x0, // 2
0x0, // 3
0x0, // 4
0x0, // 5
0x0, // 6
0x0 // 7
};
[wasm] Streaming compilation for WebAssembly. In this CL I implement streaming compilation for WebAssembly, as described in the design doc I have sent out already. In this implementation the decoding of sections other than the code section is done immediately on the foreground thread. Eventually all decoding should happen in the background. I think it is acceptable to do the decoding on the foreground thread for now because I have finished it already, and decoding in the background would add even more complexity to this CL. Bug:v8:6785 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I285e1e5e1a5a243113c92571b25ee9bae551d0ed Reviewed-on: https://chromium-review.googlesource.com/631721 Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48022}
2017-09-14 17:34:15 +00:00
ExpectVerifies(Vector<const uint8_t>(data, arraysize(data)), 2, 0);
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
}
TEST_F(WasmStreamingDecoderTest, TwoEmptySections) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
0x1, // Section ID
0x0, // Section Length
0x2, // Section ID
0x0 // Section Length
};
[wasm] Streaming compilation for WebAssembly. In this CL I implement streaming compilation for WebAssembly, as described in the design doc I have sent out already. In this implementation the decoding of sections other than the code section is done immediately on the foreground thread. Eventually all decoding should happen in the background. I think it is acceptable to do the decoding on the foreground thread for now because I have finished it already, and decoding in the background would add even more complexity to this CL. Bug:v8:6785 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I285e1e5e1a5a243113c92571b25ee9bae551d0ed Reviewed-on: https://chromium-review.googlesource.com/631721 Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48022}
2017-09-14 17:34:15 +00:00
ExpectVerifies(Vector<const uint8_t>(data, arraysize(data)), 2, 0);
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
}
TEST_F(WasmStreamingDecoderTest, OneFunction) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
kCodeSectionCode, // Section ID
0x8, // Section Length
0x1, // Number of Functions
0x6, // Function Length
0x0, // Function
0x0, // 2
0x0, // 3
0x0, // 4
0x0, // 5
0x0, // 6
};
[wasm] Streaming compilation for WebAssembly. In this CL I implement streaming compilation for WebAssembly, as described in the design doc I have sent out already. In this implementation the decoding of sections other than the code section is done immediately on the foreground thread. Eventually all decoding should happen in the background. I think it is acceptable to do the decoding on the foreground thread for now because I have finished it already, and decoding in the background would add even more complexity to this CL. Bug:v8:6785 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I285e1e5e1a5a243113c92571b25ee9bae551d0ed Reviewed-on: https://chromium-review.googlesource.com/631721 Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48022}
2017-09-14 17:34:15 +00:00
ExpectVerifies(Vector<const uint8_t>(data, arraysize(data)), 0, 1);
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
}
TEST_F(WasmStreamingDecoderTest, OneShortFunction) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
kCodeSectionCode, // Section ID
0x3, // Section Length
0x1, // Number of Functions
0x1, // Function Length
0x0, // Function
};
[wasm] Streaming compilation for WebAssembly. In this CL I implement streaming compilation for WebAssembly, as described in the design doc I have sent out already. In this implementation the decoding of sections other than the code section is done immediately on the foreground thread. Eventually all decoding should happen in the background. I think it is acceptable to do the decoding on the foreground thread for now because I have finished it already, and decoding in the background would add even more complexity to this CL. Bug:v8:6785 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I285e1e5e1a5a243113c92571b25ee9bae551d0ed Reviewed-on: https://chromium-review.googlesource.com/631721 Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48022}
2017-09-14 17:34:15 +00:00
ExpectVerifies(Vector<const uint8_t>(data, arraysize(data)), 0, 1);
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
}
TEST_F(WasmStreamingDecoderTest, EmptyFunction) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
kCodeSectionCode, // Section ID
0x2, // Section Length
0x1, // Number of Functions
0x0, // Function Length
};
ExpectFailure(Vector<const uint8_t>(data, arraysize(data)));
}
TEST_F(WasmStreamingDecoderTest, TwoFunctions) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
kCodeSectionCode, // Section ID
0x10, // Section Length
0x2, // Number of Functions
0x6, // Function Length
0x0, // Function
0x0, // 2
0x0, // 3
0x0, // 4
0x0, // 5
0x0, // 6
0x7, // Function Length
0x0, // Function
0x0, // 2
0x0, // 3
0x0, // 4
0x0, // 5
0x0, // 6
0x0, // 7
};
[wasm] Streaming compilation for WebAssembly. In this CL I implement streaming compilation for WebAssembly, as described in the design doc I have sent out already. In this implementation the decoding of sections other than the code section is done immediately on the foreground thread. Eventually all decoding should happen in the background. I think it is acceptable to do the decoding on the foreground thread for now because I have finished it already, and decoding in the background would add even more complexity to this CL. Bug:v8:6785 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I285e1e5e1a5a243113c92571b25ee9bae551d0ed Reviewed-on: https://chromium-review.googlesource.com/631721 Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48022}
2017-09-14 17:34:15 +00:00
ExpectVerifies(Vector<const uint8_t>(data, arraysize(data)), 0, 2);
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
}
TEST_F(WasmStreamingDecoderTest, TwoFunctions_b) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
kCodeSectionCode, // Section ID
0xb, // Section Length
0x2, // Number of Functions
0x1, // Function Length
0x0, // Function
0x7, // Function Length
0x0, // Function
0x0, // 2
0x0, // 3
0x0, // 4
0x0, // 5
0x0, // 6
0x0, // 7
};
[wasm] Streaming compilation for WebAssembly. In this CL I implement streaming compilation for WebAssembly, as described in the design doc I have sent out already. In this implementation the decoding of sections other than the code section is done immediately on the foreground thread. Eventually all decoding should happen in the background. I think it is acceptable to do the decoding on the foreground thread for now because I have finished it already, and decoding in the background would add even more complexity to this CL. Bug:v8:6785 Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng Change-Id: I285e1e5e1a5a243113c92571b25ee9bae551d0ed Reviewed-on: https://chromium-review.googlesource.com/631721 Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Andreas Haas <ahaas@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48022}
2017-09-14 17:34:15 +00:00
ExpectVerifies(Vector<const uint8_t>(data, arraysize(data)), 0, 2);
}
TEST_F(WasmStreamingDecoderTest, CodeSectionLengthZero) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
kCodeSectionCode, // Section ID
0x0, // Section Length
};
ExpectFailure(Vector<const uint8_t>(data, arraysize(data)));
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
}
TEST_F(WasmStreamingDecoderTest, CodeSectionLengthTooHigh) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
kCodeSectionCode, // Section ID
0xd, // Section Length
0x2, // Number of Functions
0x7, // Function Length
0x0, // Function
0x0, // 2
0x0, // 3
0x0, // 4
0x0, // 5
0x0, // 6
0x0, // 7
0x1, // Function Length
0x0, // Function
};
ExpectFailure(Vector<const uint8_t>(data, arraysize(data)));
}
TEST_F(WasmStreamingDecoderTest, CodeSectionLengthTooLow) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
kCodeSectionCode, // Section ID
0x9, // Section Length
0x2, // Number of Functions
0x7, // Function Length
0x0, // Function
0x0, // 2
0x0, // 3
0x0, // 4
0x0, // 5
0x0, // 6
0x0, // 7
0x1, // Function Length
0x0, // Function
};
ExpectFailure(Vector<const uint8_t>(data, arraysize(data)));
}
TEST_F(WasmStreamingDecoderTest, CodeSectionLengthTooLowEndsInNumFunctions) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
kCodeSectionCode, // Section ID
0x1, // Section Length
0x82, // Number of Functions
0x80, // --
0x00, // --
0x7, // Function Length
0x0, // Function
0x0, // 2
0x0, // 3
0x0, // 4
0x0, // 5
0x0, // 6
0x0, // 7
0x1, // Function Length
0x0, // Function
};
ExpectFailure(Vector<const uint8_t>(data, arraysize(data)));
}
TEST_F(WasmStreamingDecoderTest, CodeSectionLengthTooLowEndsInFunctionLength) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
kCodeSectionCode, // Section ID
0x5, // Section Length
0x82, // Number of Functions
0x80, // --
0x00, // --
0x87, // Function Length
0x80, // --
0x00, // --
0x0, // Function
0x0, // 2
0x0, // 3
0x0, // 4
0x0, // 5
0x0, // 6
0x0, // 7
0x1, // Function Length
0x0, // Function
};
ExpectFailure(Vector<const uint8_t>(data, arraysize(data)));
}
TEST_F(WasmStreamingDecoderTest, NumberOfFunctionsTooHigh) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
kCodeSectionCode, // Section ID
0xb, // Section Length
0x4, // Number of Functions
0x7, // Function Length
0x0, // Function
0x0, // 2
0x0, // 3
0x0, // 4
0x0, // 5
0x0, // 6
0x0, // 7
0x1, // Function Length
0x0, // Function
};
ExpectFailure(Vector<const uint8_t>(data, arraysize(data)));
}
TEST_F(WasmStreamingDecoderTest, NumberOfFunctionsTooLow) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
kCodeSectionCode, // Section ID
0xe, // Section Length
0x2, // Number of Functions
0x1, // Function Length
0x0, // Function
0x2, // Function Length
0x0, // Function
0x0, // 2
0x7, // Function Length
0x0, // Function
0x0, // 2
0x0, // 3
0x0, // 4
0x0, // 5
0x0, // 6
0x0, // 7
};
ExpectFailure(Vector<const uint8_t>(data, arraysize(data)));
}
[wasm] Fail upon second code section in streaming compilation At the moment we check only in the module-decoder if the sections in a module appear at most once. The code section, however, we process already before this check. With this CL we check that there is at most one code section before we start processing it. R=clemensh@chromium.org TEST=WasmStreamingDecoderTest.TwoCodeSections Bug: chromium:771916 Change-Id: Icc79d5a87ab39f450a35c688f74ea5e67cae4b3c Reviewed-on: https://chromium-review.googlesource.com/702379 Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Commit-Queue: Andreas Haas <ahaas@chromium.org> Cr-Commit-Position: refs/heads/master@{#48314}
2017-10-05 14:35:34 +00:00
TEST_F(WasmStreamingDecoderTest, TwoCodeSections) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
kCodeSectionCode, // Section ID
0x3, // Section Length
0x1, // Number of Functions
0x1, // Function Length
0x0, // Function
kCodeSectionCode, // Section ID
0x3, // Section Length
0x1, // Number of Functions
0x1, // Function Length
0x0, // Function
};
ExpectFailure(Vector<const uint8_t>(data, arraysize(data)));
}
TEST_F(WasmStreamingDecoderTest, UnknownSection) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
kCodeSectionCode, // Section ID
0x3, // Section Length
0x1, // Number of Functions
0x1, // Function Length
0x0, // Function
kUnknownSectionCode, // Section ID
0x3, // Section Length
0x1, // Name Length
0x1, // Name
0x0, // Content
};
ExpectVerifies(Vector<const uint8_t>(data, arraysize(data)), 1, 1);
}
TEST_F(WasmStreamingDecoderTest, UnknownSectionSandwich) {
const uint8_t data[] = {
U32_LE(kWasmMagic), // --
U32_LE(kWasmVersion), // --
kCodeSectionCode, // Section ID
0x3, // Section Length
0x1, // Number of Functions
0x1, // Function Length
0x0, // Function
kUnknownSectionCode, // Section ID
0x3, // Section Length
0x1, // Name Length
0x1, // Name
0x0, // Content
kCodeSectionCode, // Section ID
0x3, // Section Length
0x1, // Number of Functions
0x1, // Function Length
0x0, // Function
};
ExpectFailure(Vector<const uint8_t>(data, arraysize(data)));
}
[wasm] Streaming decoder This CL implements a streaming decoder which takes the bytes of a wasm module as an input, potentially split into multiple chunks, and decodes them into segments. Each segment either contains the payload of a whole section, or the code of a single function. The goal is that the streaming decoder is used for streaming compilation. That's where the interface comes from, see (https://cs.chromium.org/chromium/src/v8/include/v8.h?q=OnBytesReceived&sq=package:chromium&l=4060) Error positions are not reported correctly at the moment. I plan to do this in a separate CL. Change-Id: I6e3df6a91945c7baec2dc4f5de2e5f47636083df Reviewed-on: https://chromium-review.googlesource.com/471350 Commit-Queue: Andreas Haas <ahaas@chromium.org> Reviewed-by: Clemens Hammacher <clemensh@chromium.org> Reviewed-by: Mircea Trofin <mtrofin@chromium.org> Cr-Commit-Position: refs/heads/master@{#45250}
2017-05-11 08:51:54 +00:00
} // namespace wasm
} // namespace internal
} // namespace v8
Reference in New Issue Copy Permalink