test: Floating point memory instructions

Author: gumb0

test/unittests/execute_floating_point_test.cpp

@@ -417,3 +417,205 @@ TYPED_TEST(execute_floating_point_trunc, trunc)
         EXPECT_EQ(result.value.template as<IntT>(), FloatT{-1});
     }
 }
+
+TEST(execute_floating_point, f32_load)
+{
+    /* wat2wasm
+    (memory 1 1)
+    (data (i32.const 0) "\00\00\00\00") ;; 0
+    (data (i32.const 4) "\b6\f3\9d\3f") ;; 1.234
+    (data (i32.const 8) "\b6\f3\9d\bf") ;; -1.234
+    (data (i32.const 12) "\00\00\c0\7f") ;; canonical NaN
+    (data (i32.const 16) "\01\00\c0\7f") ;; arithmetic NaN
+    (data (i32.const 20) "\01\00\80\7f") ;; signaling NaN
+    (func (param i32) (result f32)
+      (f32.load (local.get 0))
+    )
+    */
+    const auto wasm = from_hex(
+        "0061736d0100000001060160017f017d0302010005030100010a0901070020002a02000b0b37060041000b0400"
+        "0000000041040b04b6f39d3f0041080b04b6f39dbf00410c0b040000c07f0041100b040100c07f0041140b0401"
+        "00807f");
+
+    auto instance = instantiate(parse(wasm));
+    EXPECT_THAT(execute(*instance, 0, {0}), Result(0.0f));
+    EXPECT_THAT(execute(*instance, 0, {4}), Result(1.234f));
+    EXPECT_THAT(execute(*instance, 0, {8}), Result(-1.234f));
+    EXPECT_THAT(execute(*instance, 0, {12}), Result(FP32::nan(FP32::canon)));
+    EXPECT_THAT(execute(*instance, 0, {16}), Result(FP32::nan(FP32::canon + 1)));
+    EXPECT_THAT(execute(*instance, 0, {20}), Result(FP32::nan(1)));
+
+    EXPECT_THAT(execute(*instance, 0, {65534}), Traps());
+    EXPECT_THAT(execute(*instance, 0, {65537}), Traps());
+}
+
+TEST(execute_floating_point, f32_load_overflow)
+{
+    /* wat2wasm
+    (memory 1 1)
+    (func (param i32) (result f32)
+      get_local 0
+      f32.load offset=0x7fffffff
+    )
+    */
+    const auto wasm = from_hex(
+        "0061736d0100000001060160017f017d0302010005030100010a0d010b0020002a02ffffffff070b");
+
+    auto instance = instantiate(parse(wasm));
+
+    // Offset is 0x7fffffff + 0 => 0x7fffffff
+    EXPECT_THAT(execute(*instance, 0, {0}), Traps());
+    // Offset is 0x7fffffff + 0x80000000 => 0xffffffff
+    EXPECT_THAT(execute(*instance, 0, {0x80000000}), Traps());
+    // Offset is 0x7fffffff + 0x80000001 => 0x100000000
+    EXPECT_THAT(execute(*instance, 0, {0x80000001}), Traps());
+}
+
+TEST(execute_floating_point, f64_load)
+{
+    /* wat2wasm
+    (memory 1 1)
+    (data (i32.const 0)  "\00\00\00\00\00\00\00\00") ;; 0
+    (data (i32.const 8)  "\58\39\b4\c8\76\be\f3\3f") ;; 1.234
+    (data (i32.const 16) "\58\39\b4\c8\76\be\f3\bf") ;; -1.234
+    (data (i32.const 24) "\00\00\00\00\00\00\f8\7f") ;; canonical NaN
+    (data (i32.const 32) "\01\00\00\00\00\00\f8\7f") ;; arithmetic NaN
+    (data (i32.const 40) "\01\00\00\00\00\00\f0\7f") ;; signaling NaN
+    (func (param i32) (result f64)
+      (f64.load (local.get 0))
+    )
+    */
+    const auto wasm = from_hex(
+        "0061736d0100000001060160017f017c0302010005030100010a0901070020002b03000b0b4f060041000b0800"
+        "000000000000000041080b085839b4c876bef33f0041100b085839b4c876bef3bf0041180b08000000000000f8"
+        "7f0041200b08010000000000f87f0041280b08010000000000f07f");
+
+    auto instance = instantiate(parse(wasm));
+    EXPECT_THAT(execute(*instance, 0, {0}), Result(0.0));
+    EXPECT_THAT(execute(*instance, 0, {8}), Result(1.234));
+    EXPECT_THAT(execute(*instance, 0, {16}), Result(-1.234));
+    EXPECT_THAT(execute(*instance, 0, {24}), Result(FP64::nan(FP64::canon)));
+    EXPECT_THAT(execute(*instance, 0, {32}), Result(FP64::nan(FP64::canon + 1)));
+    EXPECT_THAT(execute(*instance, 0, {40}), Result(FP64::nan(1)));
+
+    EXPECT_THAT(execute(*instance, 0, {65534}), Traps());
+    EXPECT_THAT(execute(*instance, 0, {65537}), Traps());
+}
+
+TEST(execute_floating_point, f64_load_overflow)
+{
+    /* wat2wasm
+    (memory 1 1)
+    (func (param i32) (result f64)
+      get_local 0
+      f64.load offset=0x7fffffff
+    )
+    */
+    const auto wasm = from_hex(
+        "0061736d0100000001060160017f017c0302010005030100010a0d010b0020002b03ffffffff070b");
+
+    auto instance = instantiate(parse(wasm));
+
+    // Offset is 0x7fffffff + 0 => 0x7fffffff
+    EXPECT_THAT(execute(*instance, 0, {0}), Traps());
+    // Offset is 0x7fffffff + 0x80000000 => 0xffffffff
+    EXPECT_THAT(execute(*instance, 0, {0x80000000}), Traps());
+    // Offset is 0x7fffffff + 0x80000001 => 0x100000000
+    EXPECT_THAT(execute(*instance, 0, {0x80000001}), Traps());
+}
+
+TEST(execute_floating_point, f32_store)
+{
+    /* wat2wasm
+    (memory 1 1)
+    (data (i32.const 0)  "\cc\cc\cc\cc\cc\cc")
+    (func (param f32 i32)
+      get_local 1
+      get_local 0
+      f32.store
+    )
+    */
+    const auto wasm = from_hex(
+        "0061736d0100000001060160027d7f000302010005030100010a0b010900200120003802000b0b0c010041000b"
+        "06cccccccccccc");
+
+    const std::tuple<float, bytes> test_cases[]{
+        {0.0f, "cc00000000cc"_bytes},
+        {1.234f, "ccb6f39d3fcc"_bytes},
+        {-1.234f, "ccb6f39dbfcc"_bytes},
+        {FP32::nan(FP32::canon), "cc0000c07fcc"_bytes},
+        {FP32::nan(FP32::canon + 1), "cc0100c07fcc"_bytes},
+        {FP32::nan(1), "cc0100807fcc"_bytes},
+    };
+
+    for (const auto& [arg, expected] : test_cases)
+    {
+        auto instance = instantiate(parse(wasm));
+
+        EXPECT_THAT(execute(*instance, 0, {arg, 1}), Result());
+        EXPECT_EQ(instance->memory->substr(0, 6), expected);
+
+        EXPECT_THAT(execute(*instance, 0, {arg, 65534}), Traps());
+        EXPECT_THAT(execute(*instance, 0, {arg, 65537}), Traps());
+    }
+}
+
+TEST(execute_floating_point, f32_store_overflow)
+{
+    /* wat2wasm
+    (memory 1 1)
+    (func (param i32)
+      get_local 0
+      f32.const 1.234
+      f32.store offset=0x7fffffff
+    )
+    */
+    const auto wasm = from_hex(
+        "0061736d0100000001050160017f00030201000504010101010a12011000200043b6f39d3f3802ffffffff070"
+        "b");
+
+    auto instance = instantiate(parse(wasm));
+
+    // Offset is 0x7fffffff + 0 => 0x7fffffff
+    EXPECT_THAT(execute(*instance, 0, {0}), Traps());
+    // Offset is 0x7fffffff + 0x80000000 => 0xffffffff
+    EXPECT_THAT(execute(*instance, 0, {0x80000000}), Traps());
+    // Offset is 0x7fffffff + 0x80000001 => 0x100000000
+    EXPECT_THAT(execute(*instance, 0, {0x80000001}), Traps());
+}
+
+TEST(execute_floating_point, f64_store)
+{
+    /* wat2wasm
+    (memory 1 1)
+    (data (i32.const 0)  "\cc\cc\cc\cc\cc\cc\cc\cc\cc\cc\cc\cc")
+    (func (param f64 i32)
+      get_local 1
+      get_local 0
+      f64.store
+    )
+    */
+    const auto wasm = from_hex(
+        "0061736d0100000001060160027c7f000302010005030100010a0b010900200120003903000b0b12010041000b"
+        "0ccccccccccccccccccccccccc");
+
+    const std::tuple<double, bytes> test_cases[]{
+        {0.0, "cc0000000000000000cc"_bytes},
+        {1.234, "cc5839b4c876bef33fcc"_bytes},
+        {-1.234, "cc5839b4c876bef3bfcc"_bytes},
+        {FP64::nan(FP64::canon), "cc000000000000f87fcc"_bytes},
+        {FP64::nan(FP64::canon + 1), "cc010000000000f87fcc"_bytes},
+        {FP64::nan(1), "cc010000000000f07fcc"_bytes},
+    };
+
+    for (const auto& [arg, expected] : test_cases)
+    {
+        auto instance = instantiate(parse(wasm));
+
+        EXPECT_THAT(execute(*instance, 0, {arg, 1}), Result());
+        EXPECT_EQ(instance->memory->substr(0, 10), expected);
+
+        EXPECT_THAT(execute(*instance, 0, {arg, 65534}), Traps());
+        EXPECT_THAT(execute(*instance, 0, {arg, 65537}), Traps());
+    }
+}