| /* |
| * Copyright (C) 2016 Apple Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY |
| * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "config.h" |
| |
| #include "B3Compilation.h" |
| #include "InitializeThreading.h" |
| #include "JSCJSValueInlines.h" |
| #include "JSString.h" |
| #include "LLIntThunks.h" |
| #include "ProtoCallFrame.h" |
| #include "VM.h" |
| #include "WASMPlan.h" |
| #include <wtf/DataLog.h> |
| #include <wtf/LEBDecoder.h> |
| |
| class CommandLine { |
| public: |
| CommandLine(int argc, char** argv) |
| { |
| parseArguments(argc, argv); |
| } |
| |
| Vector<String> m_arguments; |
| bool m_runLEBTests { false }; |
| bool m_runWASMTests { false }; |
| |
| void parseArguments(int, char**); |
| }; |
| |
| static NO_RETURN void printUsageStatement(bool help = false) |
| { |
| fprintf(stderr, "Usage: testWASM [options]\n"); |
| fprintf(stderr, " -h|--help Prints this help message\n"); |
| fprintf(stderr, " -l|--leb Runs the LEB decoder tests\n"); |
| fprintf(stderr, " -w|--web Run the WASM tests\n"); |
| fprintf(stderr, "\n"); |
| |
| exit(help ? EXIT_SUCCESS : EXIT_FAILURE); |
| } |
| |
| void CommandLine::parseArguments(int argc, char** argv) |
| { |
| int i = 1; |
| |
| for (; i < argc; ++i) { |
| const char* arg = argv[i]; |
| if (!strcmp(arg, "-h") || !strcmp(arg, "--help")) |
| printUsageStatement(true); |
| |
| if (!strcmp(arg, "-l") || !strcmp(arg, "--leb")) |
| m_runLEBTests = true; |
| |
| if (!strcmp(arg, "-w") || !strcmp(arg, "--web")) |
| m_runWASMTests = true; |
| } |
| |
| for (; i < argc; ++i) |
| m_arguments.append(argv[i]); |
| |
| } |
| |
| StaticLock crashLock; |
| |
| #define CHECK_EQ(x, y) do { \ |
| auto __x = (x); \ |
| auto __y = (y); \ |
| if (__x == __y) \ |
| break; \ |
| crashLock.lock(); \ |
| WTFReportAssertionFailure(__FILE__, __LINE__, WTF_PRETTY_FUNCTION, toCString(#x " == " #y, " (" #x " == ", __x, ", " #y " == ", __y, ")").data()); \ |
| CRASH(); \ |
| } while (false) |
| |
| #define FOR_EACH_UNSIGNED_LEB_TEST(macro) \ |
| /* Simple tests that use all the bits in the array */ \ |
| macro(({ 0x07 }), 0, true, 0x7lu, 1lu) \ |
| macro(({ 0x77 }), 0, true, 0x77lu, 1lu) \ |
| macro(({ 0x80, 0x07 }), 0, true, 0x380lu, 2lu) \ |
| macro(({ 0x89, 0x12 }), 0, true, 0x909lu, 2lu) \ |
| macro(({ 0xf3, 0x85, 0x02 }), 0, true, 0x82f3lu, 3lu) \ |
| macro(({ 0xf3, 0x85, 0xff, 0x74 }), 0, true, 0xe9fc2f3lu, 4lu) \ |
| macro(({ 0xf3, 0x85, 0xff, 0xf4, 0x7f }), 0, true, 0xfe9fc2f3lu, 5lu) \ |
| /* Test with extra trailing numbers */ \ |
| macro(({ 0x07, 0x80 }), 0, true, 0x7lu, 1lu) \ |
| macro(({ 0x07, 0x75 }), 0, true, 0x7lu, 1lu) \ |
| macro(({ 0xf3, 0x85, 0xff, 0x74, 0x43 }), 0, true, 0xe9fc2f3lu, 4lu) \ |
| macro(({ 0xf3, 0x85, 0xff, 0x74, 0x80 }), 0, true, 0xe9fc2f3lu, 4lu) \ |
| /* Test with preceeding numbers */ \ |
| macro(({ 0xf3, 0x07 }), 1, true, 0x7lu, 2lu) \ |
| macro(({ 0x03, 0x07 }), 1, true, 0x7lu, 2lu) \ |
| macro(({ 0xf2, 0x53, 0x43, 0x67, 0x79, 0x77 }), 5, true, 0x77lu, 6lu) \ |
| macro(({ 0xf2, 0x53, 0x43, 0xf7, 0x84, 0x77 }), 5, true, 0x77lu, 6ul) \ |
| macro(({ 0xf2, 0x53, 0x43, 0xf3, 0x85, 0x02 }), 3, true, 0x82f3lu, 6lu) \ |
| /* Test in the middle */ \ |
| macro(({ 0xf3, 0x07, 0x89 }), 1, true, 0x7lu, 2lu) \ |
| macro(({ 0x03, 0x07, 0x23 }), 1, true, 0x7lu, 2lu) \ |
| macro(({ 0xf2, 0x53, 0x43, 0x67, 0x79, 0x77, 0x43 }), 5, true, 0x77lu, 6lu) \ |
| macro(({ 0xf2, 0x53, 0x43, 0xf7, 0x84, 0x77, 0xf9 }), 5, true, 0x77lu, 6lu) \ |
| macro(({ 0xf2, 0x53, 0x43, 0xf3, 0x85, 0x02, 0xa4 }), 3, true, 0x82f3lu, 6lu) \ |
| /* Test decode too long */ \ |
| macro(({ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80}), 0, false, 0x0lu, 0lu) \ |
| macro(({ 0x80, 0x80, 0xab, 0x8a, 0x9a, 0xa3, 0xff}), 1, false, 0x0lu, 0lu) \ |
| macro(({ 0x80, 0x80, 0xab, 0x8a, 0x9a, 0xa3, 0xff}), 0, false, 0x0lu, 0lu) \ |
| /* Test decode off end of array */ \ |
| macro(({ 0x80, 0x80, 0xab, 0x8a, 0x9a, 0xa3, 0xff}), 2, false, 0x0lu, 0lu) \ |
| |
| |
| #define TEST_UNSIGNED_LEB_DECODE(init, startOffset, expectedStatus, expectedResult, expectedOffset) \ |
| { \ |
| Vector<uint8_t> vector = Vector<uint8_t> init; \ |
| size_t offset = startOffset; \ |
| uint32_t result; \ |
| bool status = decodeUInt32(vector.data(), vector.size(), offset, result); \ |
| CHECK_EQ(status, expectedStatus); \ |
| if (expectedStatus) { \ |
| CHECK_EQ(result, expectedResult); \ |
| CHECK_EQ(offset, expectedOffset); \ |
| } \ |
| }; |
| |
| |
| #define FOR_EACH_SIGNED_LEB_TEST(macro) \ |
| /* Simple tests that use all the bits in the array */ \ |
| macro(({ 0x07 }), 0, true, 0x7, 1lu) \ |
| macro(({ 0x77 }), 0, true, -0x9, 1lu) \ |
| macro(({ 0x80, 0x07 }), 0, true, 0x380, 2lu) \ |
| macro(({ 0x89, 0x12 }), 0, true, 0x909, 2lu) \ |
| macro(({ 0xf3, 0x85, 0x02 }), 0, true, 0x82f3, 3lu) \ |
| macro(({ 0xf3, 0x85, 0xff, 0x74 }), 0, true, 0xfe9fc2f3, 4lu) \ |
| macro(({ 0xf3, 0x85, 0xff, 0xf4, 0x7f }), 0, true, 0xfe9fc2f3, 5lu) \ |
| /* Test with extra trailing numbers */ \ |
| macro(({ 0x07, 0x80 }), 0, true, 0x7, 1lu) \ |
| macro(({ 0x07, 0x75 }), 0, true, 0x7, 1lu) \ |
| macro(({ 0xf3, 0x85, 0xff, 0x74, 0x43 }), 0, true, 0xfe9fc2f3, 4lu) \ |
| macro(({ 0xf3, 0x85, 0xff, 0x74, 0x80 }), 0, true, 0xfe9fc2f3, 4lu) \ |
| /* Test with preceeding numbers */ \ |
| macro(({ 0xf3, 0x07 }), 1, true, 0x7, 2lu) \ |
| macro(({ 0x03, 0x07 }), 1, true, 0x7, 2lu) \ |
| macro(({ 0xf2, 0x53, 0x43, 0x67, 0x79, 0x77 }), 5, true, -0x9, 6lu) \ |
| macro(({ 0xf2, 0x53, 0x43, 0xf7, 0x84, 0x77 }), 5, true, -0x9, 6lu) \ |
| macro(({ 0xf2, 0x53, 0x43, 0xf3, 0x85, 0x02 }), 3, true, 0x82f3, 6lu) \ |
| /* Test in the middle */ \ |
| macro(({ 0xf3, 0x07, 0x89 }), 1, true, 0x7, 2lu) \ |
| macro(({ 0x03, 0x07, 0x23 }), 1, true, 0x7, 2lu) \ |
| macro(({ 0xf2, 0x53, 0x43, 0x67, 0x79, 0x77, 0x43 }), 5, true, -0x9, 6lu) \ |
| macro(({ 0xf2, 0x53, 0x43, 0xf7, 0x84, 0x77, 0xf9 }), 5, true, -0x9, 6lu) \ |
| macro(({ 0xf2, 0x53, 0x43, 0xf3, 0x85, 0x02, 0xa4 }), 3, true, 0x82f3, 6lu) \ |
| /* Test decode too long */ \ |
| macro(({ 0x80, 0x80, 0x80, 0x80, 0x80, 0x80}), 0, false, 0x0, 0lu) \ |
| macro(({ 0x80, 0x80, 0xab, 0x8a, 0x9a, 0xa3, 0xff}), 1, false, 0x0, 0lu) \ |
| macro(({ 0x80, 0x80, 0xab, 0x8a, 0x9a, 0xa3, 0xff}), 0, false, 0x0, 0lu) \ |
| /* Test decode off end of array */ \ |
| macro(({ 0x80, 0x80, 0xab, 0x8a, 0x9a, 0xa3, 0xff}), 2, false, 0x0, 0lu) \ |
| |
| |
| #define TEST_SIGNED_LEB_DECODE(init, startOffset, expectedStatus, expectedResult, expectedOffset) \ |
| { \ |
| Vector<uint8_t> vector = Vector<uint8_t> init; \ |
| size_t offset = startOffset; \ |
| int32_t result; \ |
| bool status = decodeInt32(vector.data(), vector.size(), offset, result); \ |
| CHECK_EQ(status, expectedStatus); \ |
| if (expectedStatus) { \ |
| int32_t expected = expectedResult; \ |
| CHECK_EQ(result, expected); \ |
| CHECK_EQ(offset, expectedOffset); \ |
| } \ |
| }; |
| |
| |
| static void runLEBTests() |
| { |
| FOR_EACH_UNSIGNED_LEB_TEST(TEST_UNSIGNED_LEB_DECODE) |
| FOR_EACH_SIGNED_LEB_TEST(TEST_SIGNED_LEB_DECODE) |
| } |
| |
| #if ENABLE(WEBASSEMBLY) |
| |
| static JSC::VM* vm; |
| |
| using namespace JSC; |
| using namespace WASM; |
| using namespace B3; |
| |
| template<typename T> |
| T invoke(MacroAssemblerCodePtr ptr, std::initializer_list<JSValue> args) |
| { |
| JSValue firstArgument; |
| // Since vmEntryToJavaScript expects a this value we claim there is one... there isn't. |
| int argCount = 1; |
| JSValue* remainingArguments = nullptr; |
| if (args.size()) { |
| remainingArguments = const_cast<JSValue*>(args.begin()); |
| firstArgument = *remainingArguments; |
| remainingArguments++; |
| argCount = args.size(); |
| } |
| |
| ProtoCallFrame protoCallFrame; |
| protoCallFrame.init(nullptr, nullptr, firstArgument, argCount, remainingArguments); |
| |
| // This won't work for floating point values but we don't have those yet. |
| return static_cast<T>(vmEntryToWASM(ptr.executableAddress(), vm, &protoCallFrame)); |
| } |
| |
| template<typename T> |
| T invoke(const Compilation& code, std::initializer_list<JSValue> args) |
| { |
| return invoke<T>(code.code(), args); |
| } |
| |
| inline JSValue box(uint64_t value) |
| { |
| return JSValue::decode(value); |
| } |
| |
| // For now we inline the test files. |
| static void runWASMTests() |
| { |
| { |
| // Generated from: |
| // (module |
| // (func (export "dumb-eq") (param $x i32) (param $y i32) (result i32) |
| // (if (i32.eq (get_local $x) (get_local $y)) |
| // (then (br 0)) |
| // (else (return (i32.const 1)))) |
| // (return (i32.const 0)) |
| // ) |
| // ) |
| Vector<uint8_t> vector = { |
| 0x00, 0x61, 0x73, 0x6d, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x87, 0x80, 0x80, 0x80, 0x00, 0x01, 0x40, |
| 0x02, 0x01, 0x01, 0x01, 0x01, 0x03, 0x82, 0x80, 0x80, 0x80, 0x00, 0x01, 0x00, 0x07, 0x8b, 0x80, |
| 0x80, 0x80, 0x00, 0x01, 0x07, 0x64, 0x75, 0x6d, 0x62, 0x2d, 0x65, 0x71, 0x00, 0x00, 0x0a, 0x99, |
| 0x80, 0x80, 0x80, 0x00, 0x01, 0x93, 0x80, 0x80, 0x80, 0x00, 0x00, 0x14, 0x00, 0x14, 0x01, 0x4d, |
| 0x03, 0x00, 0x06, 0x00, 0x04, 0x10, 0x01, 0x09, 0x0f, 0x10, 0x00, 0x09, 0x0f |
| }; |
| |
| Plan plan(*vm, vector); |
| if (plan.result.size() != 1 || !plan.result[0]) { |
| dataLogLn("Module failed to compile correctly."); |
| CRASH(); |
| } |
| |
| // Test this doesn't crash. |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(0), box(1) }), 1); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(1), box(0) }), 1); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(2), box(1) }), 1); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(1), box(2) }), 1); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(2), box(2) }), 0); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(1), box(1) }), 0); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(2), box(6) }), 1); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(100), box(6) }), 1); |
| } |
| |
| { |
| // Generated from: |
| // (module |
| // (func (export "dumb-less-than") (param $x i32) (param $y i32) (result i32) |
| // (loop |
| // (if (i32.eq (get_local $x) (get_local $y)) |
| // (then (return (i32.const 0))) |
| // (else (if (i32.eq (get_local $x) (i32.const 0)) |
| // (return (i32.const 1))))) |
| // (set_local $x (i32.sub (get_local $x) (i32.const 1))) |
| // (br 0) |
| // ) |
| // ) |
| // ) |
| Vector<uint8_t> vector = { |
| 0x00, 0x61, 0x73, 0x6d, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x87, 0x80, 0x80, 0x80, 0x00, 0x01, 0x40, |
| 0x02, 0x01, 0x01, 0x01, 0x01, 0x03, 0x82, 0x80, 0x80, 0x80, 0x00, 0x01, 0x00, 0x07, 0x92, 0x80, |
| 0x80, 0x80, 0x00, 0x01, 0x0e, 0x64, 0x75, 0x6d, 0x62, 0x2d, 0x6c, 0x65, 0x73, 0x73, 0x2d, 0x74, |
| 0x68, 0x61, 0x6e, 0x00, 0x00, 0x0a, 0xac, 0x80, 0x80, 0x80, 0x00, 0x01, 0xa6, 0x80, 0x80, 0x80, |
| 0x00, 0x00, 0x02, 0x00, 0x14, 0x00, 0x14, 0x01, 0x4d, 0x03, 0x00, 0x10, 0x00, 0x09, 0x04, 0x14, |
| 0x00, 0x10, 0x00, 0x4d, 0x03, 0x00, 0x10, 0x01, 0x09, 0x0f, 0x0f, 0x14, 0x00, 0x10, 0x01, 0x41, |
| 0x15, 0x00, 0x06, 0x00, 0x0f, 0x00, 0x0f |
| }; |
| |
| Plan plan(*vm, vector); |
| if (plan.result.size() != 1 || !plan.result[0]) { |
| dataLogLn("Module failed to compile correctly."); |
| CRASH(); |
| } |
| |
| // Test this doesn't crash. |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(0), box(1) }), 1); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(1), box(0) }), 0); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(2), box(1) }), 0); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(1), box(2) }), 1); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(2), box(2) }), 0); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(1), box(1) }), 0); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(2), box(6) }), 1); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(100), box(6) }), 0); |
| } |
| |
| |
| { |
| // Generated from: (module (func (export "return-i32") (result i32) (return (i32.const 5))) ) |
| Vector<uint8_t> vector = { |
| 0x00, 0x61, 0x73, 0x6d, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x85, 0x80, 0x80, 0x80, 0x00, 0x01, 0x40, |
| 0x00, 0x01, 0x01, 0x03, 0x82, 0x80, 0x80, 0x80, 0x00, 0x01, 0x00, 0x07, 0x8e, 0x80, 0x80, 0x80, |
| 0x00, 0x01, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x2d, 0x69, 0x33, 0x32, 0x00, 0x00, 0x0a, |
| 0x8b, 0x80, 0x80, 0x80, 0x00, 0x01, 0x85, 0x80, 0x80, 0x80, 0x00, 0x00, 0x10, 0x05, 0x09, 0x0f |
| }; |
| |
| Plan plan(*vm, vector); |
| if (plan.result.size() != 1 || !plan.result[0]) { |
| dataLogLn("Module failed to compile correctly."); |
| CRASH(); |
| } |
| |
| // Test this doesn't crash. |
| CHECK_EQ(invoke<int>(*plan.result[0], { }), 5); |
| } |
| |
| |
| { |
| // Generated from: (module (func (export "return-i32") (result i32) (return (i32.add (i32.const 5) (i32.const 6)))) ) |
| Vector<uint8_t> vector = { |
| 0x00, 0x61, 0x73, 0x6d, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x85, 0x80, 0x80, 0x80, 0x00, 0x01, 0x40, |
| 0x00, 0x01, 0x01, 0x03, 0x82, 0x80, 0x80, 0x80, 0x00, 0x01, 0x00, 0x07, 0x8e, 0x80, 0x80, 0x80, |
| 0x00, 0x01, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x2d, 0x69, 0x33, 0x32, 0x00, 0x00, 0x0a, |
| 0x8e, 0x80, 0x80, 0x80, 0x00, 0x01, 0x88, 0x80, 0x80, 0x80, 0x00, 0x00, 0x10, 0x05, 0x10, 0x06, |
| 0x40, 0x09, 0x0f |
| }; |
| |
| Plan plan(*vm, vector); |
| if (plan.result.size() != 1 || !plan.result[0]) { |
| dataLogLn("Module failed to compile correctly."); |
| CRASH(); |
| } |
| |
| // Test this doesn't crash. |
| CHECK_EQ(invoke<int>(*plan.result[0], { }), 11); |
| } |
| |
| { |
| // Generated from: (module (func (export "return-i32") (result i32) (return (i32.add (i32.add (i32.const 5) (i32.const 3)) (i32.const 3)))) ) |
| Vector<uint8_t> vector = { |
| 0x00, 0x61, 0x73, 0x6d, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x85, 0x80, 0x80, 0x80, 0x00, 0x01, 0x40, |
| 0x00, 0x01, 0x01, 0x03, 0x82, 0x80, 0x80, 0x80, 0x00, 0x01, 0x00, 0x07, 0x8e, 0x80, 0x80, 0x80, |
| 0x00, 0x01, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x2d, 0x69, 0x33, 0x32, 0x00, 0x00, 0x0a, |
| 0x91, 0x80, 0x80, 0x80, 0x00, 0x01, 0x8b, 0x80, 0x80, 0x80, 0x00, 0x00, 0x10, 0x05, 0x10, 0x03, |
| 0x40, 0x10, 0x03, 0x40, 0x09, 0x0f |
| }; |
| |
| Plan plan(*vm, vector); |
| if (plan.result.size() != 1 || !plan.result[0]) { |
| dataLogLn("Module failed to compile correctly."); |
| CRASH(); |
| } |
| |
| // Test this doesn't crash. |
| CHECK_EQ(invoke<int>(*plan.result[0], { }), 11); |
| } |
| |
| { |
| // Generated from: (module (func (export "return-i32") (result i32) (block (return (i32.add (i32.add (i32.const 5) (i32.const 3)) (i32.const 3)))) (unreachable)) ) |
| Vector<uint8_t> vector = { |
| 0x00, 0x61, 0x73, 0x6d, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x85, 0x80, 0x80, 0x80, 0x00, 0x01, 0x40, |
| 0x00, 0x01, 0x01, 0x03, 0x82, 0x80, 0x80, 0x80, 0x00, 0x01, 0x00, 0x07, 0x8e, 0x80, 0x80, 0x80, |
| 0x00, 0x01, 0x0a, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x2d, 0x69, 0x33, 0x32, 0x00, 0x00, 0x0a, |
| 0x95, 0x80, 0x80, 0x80, 0x00, 0x01, 0x8f, 0x80, 0x80, 0x80, 0x00, 0x00, 0x01, 0x00, 0x10, 0x05, |
| 0x10, 0x03, 0x40, 0x10, 0x03, 0x40, 0x09, 0x0f, 0x00, 0x0f |
| }; |
| |
| Plan plan(*vm, vector); |
| if (plan.result.size() != 1 || !plan.result[0]) { |
| dataLogLn("Module failed to compile correctly."); |
| CRASH(); |
| } |
| |
| // Test this doesn't crash. |
| CHECK_EQ(invoke<int>(*plan.result[0], { }), 11); |
| } |
| |
| { |
| // Generated from: (module (func (export "add") (param $x i32) (param $y i32) (result i32) (return (i32.add (get_local $x) (get_local $y)))) ) |
| Vector<uint8_t> vector = { |
| 0x00, 0x61, 0x73, 0x6d, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x87, 0x80, 0x80, 0x80, 0x00, 0x01, 0x40, |
| 0x02, 0x01, 0x01, 0x01, 0x01, 0x03, 0x82, 0x80, 0x80, 0x80, 0x00, 0x01, 0x00, 0x07, 0x87, 0x80, |
| 0x80, 0x80, 0x00, 0x01, 0x03, 0x61, 0x64, 0x64, 0x00, 0x00, 0x0a, 0x8e, 0x80, 0x80, 0x80, 0x00, |
| 0x01, 0x88, 0x80, 0x80, 0x80, 0x00, 0x00, 0x14, 0x00, 0x14, 0x01, 0x40, 0x09, 0x0f |
| }; |
| |
| Plan plan(*vm, vector); |
| if (plan.result.size() != 1 || !plan.result[0]) { |
| dataLogLn("Module failed to compile correctly."); |
| CRASH(); |
| } |
| |
| // Test this doesn't crash. |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(0), box(1) }), 1); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(100), box(1) }), 101); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(-1), box(1)}), 0); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(std::numeric_limits<int>::max()), box(1) }), std::numeric_limits<int>::min()); |
| } |
| |
| { |
| // Generated from: |
| // (module |
| // (func (export "locals") (param $x i32) (result i32) (local $num i32) |
| // (set_local $num (get_local $x)) |
| // (return (get_local $num)) |
| // ) |
| // ) |
| Vector<uint8_t> vector = { |
| 0x00, 0x61, 0x73, 0x6d, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x86, 0x80, 0x80, 0x80, 0x00, 0x01, 0x40, |
| 0x01, 0x01, 0x01, 0x01, 0x03, 0x82, 0x80, 0x80, 0x80, 0x00, 0x01, 0x00, 0x07, 0x8a, 0x80, 0x80, |
| 0x80, 0x00, 0x01, 0x06, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x73, 0x00, 0x00, 0x0a, 0x91, 0x80, 0x80, |
| 0x80, 0x00, 0x01, 0x8b, 0x80, 0x80, 0x80, 0x00, 0x01, 0x01, 0x01, 0x14, 0x00, 0x15, 0x01, 0x14, |
| 0x01, 0x09, 0x0f |
| }; |
| |
| Plan plan(*vm, vector); |
| if (plan.result.size() != 1 || !plan.result[0]) { |
| dataLogLn("Module failed to compile correctly."); |
| CRASH(); |
| } |
| |
| // Test this doesn't crash. |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(0) }), 0); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(10) }), 10); |
| } |
| |
| { |
| // Generated from: |
| // (module |
| // (func (export "sum") (param $x i32) (result i32) (local $y i32) |
| // (set_local $y (i32.const 0)) |
| // (loop |
| // (block |
| // (br_if 0 (i32.eq (get_local $x) (i32.const 0))) |
| // (set_local $y (i32.add (get_local $x) (get_local $y))) |
| // (set_local $x (i32.sub (get_local $x) (i32.const 1))) |
| // (br 1) |
| // ) |
| // ) |
| // (return (get_local $y)) |
| // ) |
| // ) |
| Vector<uint8_t> vector = { |
| 0x00, 0x61, 0x73, 0x6d, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x86, 0x80, 0x80, 0x80, 0x00, 0x01, 0x40, |
| 0x01, 0x01, 0x01, 0x01, 0x03, 0x82, 0x80, 0x80, 0x80, 0x00, 0x01, 0x00, 0x07, 0x87, 0x80, 0x80, |
| 0x80, 0x00, 0x01, 0x03, 0x73, 0x75, 0x6d, 0x00, 0x00, 0x0a, 0xae, 0x80, 0x80, 0x80, 0x00, 0x01, |
| 0xa8, 0x80, 0x80, 0x80, 0x00, 0x01, 0x01, 0x01, 0x10, 0x00, 0x15, 0x01, 0x02, 0x00, 0x01, 0x00, |
| 0x14, 0x00, 0x10, 0x00, 0x4d, 0x07, 0x00, 0x14, 0x00, 0x14, 0x01, 0x40, 0x15, 0x01, 0x14, 0x00, |
| 0x10, 0x01, 0x41, 0x15, 0x00, 0x06, 0x01, 0x0f, 0x0f, 0x14, 0x01, 0x09, 0x0f |
| }; |
| |
| Plan plan(*vm, vector); |
| if (plan.result.size() != 1 || !plan.result[0]) { |
| dataLogLn("Module failed to compile correctly."); |
| CRASH(); |
| } |
| |
| // Test this doesn't crash. |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(0) }), 0); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(1) }), 1); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(2)}), 3); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(100) }), 5050); |
| } |
| |
| { |
| // Generated from: |
| // (module |
| // (func (export "dumb-mult") (param $x i32) (param $y i32) (result i32) (local $total i32) (local $i i32) (local $j i32) |
| // (set_local $total (i32.const 0)) |
| // (set_local $i (i32.const 0)) |
| // (block (loop |
| // (br_if 1 (i32.eq (get_local $i) (get_local $x))) |
| // (set_local $j (i32.const 0)) |
| // (set_local $i (i32.add (get_local $i) (i32.const 1))) |
| // (loop |
| // (br_if 1 (i32.eq (get_local $j) (get_local $y))) |
| // (set_local $total (i32.add (get_local $total) (i32.const 1))) |
| // (set_local $j (i32.add (get_local $j) (i32.const 1))) |
| // (br 0) |
| // ) |
| // )) |
| // (return (get_local $total)) |
| // ) |
| // ) |
| Vector<uint8_t> vector = { |
| 0x00, 0x61, 0x73, 0x6d, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x87, 0x80, 0x80, 0x80, 0x00, 0x01, 0x40, |
| 0x02, 0x01, 0x01, 0x01, 0x01, 0x03, 0x82, 0x80, 0x80, 0x80, 0x00, 0x01, 0x00, 0x07, 0x8d, 0x80, |
| 0x80, 0x80, 0x00, 0x01, 0x09, 0x64, 0x75, 0x6d, 0x62, 0x2d, 0x6d, 0x75, 0x6c, 0x74, 0x00, 0x00, |
| 0x0a, 0xc7, 0x80, 0x80, 0x80, 0x00, 0x01, 0xc1, 0x80, 0x80, 0x80, 0x00, 0x01, 0x03, 0x01, 0x10, |
| 0x00, 0x15, 0x02, 0x10, 0x00, 0x15, 0x03, 0x01, 0x00, 0x02, 0x00, 0x14, 0x03, 0x14, 0x00, 0x4d, |
| 0x07, 0x01, 0x10, 0x00, 0x15, 0x04, 0x14, 0x03, 0x10, 0x01, 0x40, 0x15, 0x03, 0x02, 0x00, 0x14, |
| 0x04, 0x14, 0x01, 0x4d, 0x07, 0x01, 0x14, 0x02, 0x10, 0x01, 0x40, 0x15, 0x02, 0x14, 0x04, 0x10, |
| 0x01, 0x40, 0x15, 0x04, 0x06, 0x00, 0x0f, 0x0f, 0x0f, 0x14, 0x02, 0x09, 0x0f |
| }; |
| |
| Plan plan(*vm, vector); |
| if (plan.result.size() != 1 || !plan.result[0]) { |
| dataLogLn("Module failed to compile correctly."); |
| CRASH(); |
| } |
| |
| // Test this doesn't crash. |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(0), box(1) }), 0); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(1), box(0) }), 0); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(2), box(1) }), 2); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(1), box(2) }), 2); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(2), box(2) }), 4); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(2), box(6) }), 12); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(100), box(6) }), 600); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(100), box(100) }), 10000); |
| } |
| |
| { |
| // Generated from: |
| // (module |
| // (func "dumb-less-than" (param $x i32) (param $y i32) (result i32) |
| // (loop |
| // (block |
| // (block |
| // (br_if 0 (i32.eq (get_local $x) (get_local $y))) |
| // (br 1) |
| // ) |
| // (return (i32.const 0)) |
| // ) |
| // (block |
| // (block |
| // (br_if 0 (i32.eq (get_local $x) (i32.const 0))) |
| // (br 1) |
| // ) |
| // (return (i32.const 1)) |
| // ) |
| // (set_local $x (i32.sub (get_local $x) (i32.const 1))) |
| // (br 0) |
| // ) |
| // (unreachable) |
| // ) |
| // ) |
| Vector<uint8_t> vector = { |
| 0x00, 0x61, 0x73, 0x6d, 0x0c, 0x00, 0x00, 0x00, 0x01, 0x87, 0x80, 0x80, 0x80, 0x00, 0x01, 0x40, |
| 0x02, 0x01, 0x01, 0x01, 0x01, 0x03, 0x82, 0x80, 0x80, 0x80, 0x00, 0x01, 0x00, 0x07, 0x92, 0x80, |
| 0x80, 0x80, 0x00, 0x01, 0x0e, 0x64, 0x75, 0x6d, 0x62, 0x2d, 0x6c, 0x65, 0x73, 0x73, 0x2d, 0x74, |
| 0x68, 0x61, 0x6e, 0x00, 0x00, 0x0a, 0xb9, 0x80, 0x80, 0x80, 0x00, 0x01, 0xb3, 0x80, 0x80, 0x80, |
| 0x00, 0x00, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, 0x14, 0x00, 0x14, 0x01, 0x4d, 0x07, 0x00, 0x06, |
| 0x01, 0x0f, 0x10, 0x00, 0x09, 0x0f, 0x01, 0x00, 0x01, 0x00, 0x14, 0x00, 0x10, 0x00, 0x4d, 0x07, |
| 0x00, 0x06, 0x01, 0x0f, 0x10, 0x01, 0x09, 0x0f, 0x14, 0x00, 0x10, 0x01, 0x41, 0x15, 0x00, 0x06, |
| 0x00, 0x0f, 0x00, 0x0f |
| }; |
| |
| Plan plan(*vm, vector); |
| if (plan.result.size() != 1 || !plan.result[0]) { |
| dataLogLn("Module failed to compile correctly."); |
| CRASH(); |
| } |
| |
| // Test this doesn't crash. |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(0), box(1) }), 1); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(1), box(0) }), 0); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(2), box(1) }), 0); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(1), box(2) }), 1); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(2), box(2) }), 0); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(1), box(1) }), 0); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(2), box(6) }), 1); |
| CHECK_EQ(invoke<int>(*plan.result[0], { box(100), box(6) }), 0); |
| } |
| |
| } |
| |
| #endif // ENABLE(WEBASSEMBLY) |
| |
| int main(int argc, char** argv) |
| { |
| CommandLine options(argc, argv); |
| |
| if (options.m_runLEBTests) |
| runLEBTests(); |
| |
| |
| if (options.m_runWASMTests) { |
| #if ENABLE(WEBASSEMBLY) |
| JSC::initializeThreading(); |
| vm = &JSC::VM::create(JSC::LargeHeap).leakRef(); |
| runWASMTests(); |
| #else |
| dataLogLn("WASM is not enabled!"); |
| return EXIT_FAILURE; |
| #endif // ENABLE(WEBASSEMBLY) |
| } |
| |
| return EXIT_SUCCESS; |
| } |
| |
