Implement floating point memory instructions

Author: gumb0

lib/fizzy/execute.cpp

@@ -324,11 +324,23 @@ inline DstT extend(SrcT in) noexcept
         return DstT{in};
 }
 
+template<>
+inline float extend(float in) noexcept
+{
+    return in;
+}
+
+template<>
+inline double extend(double in) noexcept
+{
+    return in;
+}
+
 template <typename DstT, typename SrcT = DstT>
 inline bool load_from_memory(
     bytes_view memory, OperandStack& stack, const uint8_t*& immediates) noexcept
 {
-    const auto address = static_cast<uint32_t>(stack.pop());
+    const auto address = stack.pop().as<uint32_t>();
     // NOTE: alignment is dropped by the parser
     const auto offset = read<uint32_t>(immediates);
     // Addressing is 32-bit, but we keep the value as 64-bit to detect overflows.
@@ -340,12 +352,21 @@ inline bool load_from_memory(
     return true;
 }
 
+template <typename T>
+inline T pop_store_memory_arg(OperandStack& stack) noexcept
+{
+    if constexpr (std::is_floating_point_v<T>)
+        return stack.pop().as<T>();
+    else
+        return static_cast<T>(stack.pop().i64);
+}
+
 template <typename DstT>
 inline bool store_into_memory(
     bytes& memory, OperandStack& stack, const uint8_t*& immediates) noexcept
 {
-    const auto value = static_cast<DstT>(stack.pop());
-    const auto address = static_cast<uint32_t>(stack.pop());
+    const auto value = pop_store_memory_arg<DstT>(stack);
+    const auto address = stack.pop().as<uint32_t>();
     // NOTE: alignment is dropped by the parser
     const auto offset = read<uint32_t>(immediates);
     // Addressing is 32-bit, but we keep the value as 64-bit to detect overflows.
@@ -835,6 +856,24 @@ ExecutionResult execute(Instance& instance, FuncIdx func_idx, span<const Value>
             }
             break;
         }
+        case Instr::f32_load:
+        {
+            if (!load_from_memory<float>(*memory, stack, immediates))
+            {
+                trap = true;
+                goto end;
+            }
+            break;
+        }
+        case Instr::f64_load:
+        {
+            if (!load_from_memory<double>(*memory, stack, immediates))
+            {
+                trap = true;
+                goto end;
+            }
+            break;
+        }
         case Instr::i32_load8_s:
         {
             if (!load_from_memory<uint32_t, int8_t>(*memory, stack, immediates))
@@ -943,6 +982,24 @@ ExecutionResult execute(Instance& instance, FuncIdx func_idx, span<const Value>
             }
             break;
         }
+        case Instr::f32_store:
+        {
+            if (!store_into_memory<float>(*memory, stack, immediates))
+            {
+                trap = true;
+                goto end;
+            }
+            break;
+        }
+        case Instr::f64_store:
+        {
+            if (!store_into_memory<double>(*memory, stack, immediates))
+            {
+                trap = true;
+                goto end;
+            }
+            break;
+        }
         case Instr::i32_store8:
         case Instr::i64_store8:
         {
@@ -1397,10 +1454,6 @@ ExecutionResult execute(Instance& instance, FuncIdx func_idx, span<const Value>
             break;
         }
 
-        case Instr::f32_load:
-        case Instr::f64_load:
-        case Instr::f32_store:
-        case Instr::f64_store:
         case Instr::f32_eq:
         case Instr::f32_ne:
         case Instr::f32_lt: