fix: lower_flat_values missing store

Signed-off-by Gordon Smith <GordonJSmith@gmail.com>

Author: GordonSmith

include/cmcpp/lower.hpp

@@ -74,6 +74,7 @@ namespace cmcpp
         WasmValVector flat_vals = {ptr};
         trap_if(cx, ptr != align_to(ptr, ValTrait<tuple_type>::alignment));
         trap_if(cx, ptr + ValTrait<tuple_type>::size > cx.opts.memory.size());
+        store(cx, vs, ptr);
         return flat_vals;
     }
 

include/cmcpp/tuple.hpp

@@ -17,13 +17,14 @@ namespace cmcpp
     {
 
         template <Tuple T>
-        void store(const LiftLowerContext &cx, const T &v, uint32_t ptr)
+        void store(LiftLowerContext &cx, const T &v, uint32_t ptr)
         {
             auto process_field = [&](auto &&field)
             {
-                ptr = align_to(ptr, ValTrait<std::remove_reference_t<decltype(field)>>::alignment);
-                store(cx, field, ptr);
-                ptr += ValTrait<std::remove_reference_t<decltype(field)>>::size;
+                using field_type = std::remove_const_t<std::remove_reference_t<decltype(field)>>;
+                ptr = align_to(ptr, ValTrait<field_type>::alignment);
+                cmcpp::store(cx, field, ptr);
+                ptr += ValTrait<field_type>::size;
             };
 
             std::apply([&](auto &&...fields)

samples/wamr/main.cpp

@@ -166,7 +166,7 @@ int main()
         using params_t = ValTrait<and_func_t>::params_t;
         using results_t = ValTrait<and_func_t>::results_t;
 
-        auto inputs = toWamr(lower_flat_values(liftLowerContext, MAX_FLAT_PARAMS, params_t{a, b}));
+        auto inputs = toWamr(lower_flat_values<params_t>(liftLowerContext, MAX_FLAT_PARAMS, {a, b}));
         auto output_size = 1;
         wasm_val_t outputs[output_size];
         auto call_result = wasm_runtime_call_wasm_a(exec_env, and_func, output_size, outputs, inputs.size(), inputs.data());
@@ -186,7 +186,7 @@ int main()
         using params_t = ValTrait<add_func_t>::params_t;
         using results_t = ValTrait<add_func_t>::results_t;
 
-        auto inputs = toWamr(lower_flat_values(liftLowerContext, MAX_FLAT_PARAMS, params_t{input1, input2}));
+        auto inputs = toWamr(lower_flat_values<params_t>(liftLowerContext, MAX_FLAT_PARAMS, {input1, input2}));
         auto output_size = 1;
         wasm_val_t outputs[output_size];
         auto call_result = wasm_runtime_call_wasm_a(exec_env, add_func, output_size, outputs, inputs.size(), inputs.data());
@@ -207,7 +207,7 @@ int main()
         using params_t = ValTrait<reverse_func_t>::params_t;
         using results_t = ValTrait<reverse_func_t>::results_t;
 
-        auto inputs = toWamr(lower_flat_values(liftLowerContext, MAX_FLAT_PARAMS, params_t{input1}));
+        auto inputs = toWamr(lower_flat_values<params_t>(liftLowerContext, MAX_FLAT_PARAMS, {input1}));
         auto output_size = 1;
         wasm_val_t outputs[output_size];
         auto call_result = wasm_runtime_call_wasm_a(exec_env, reverse_func, output_size, outputs, inputs.size(), inputs.data());
@@ -218,44 +218,70 @@ int main()
     auto call_reverse_result = call_reverse("Hello World!");
     call_reverse(call_reverse_result);
 
-    using reverse_tuple_func_t = func_t<tuple_t<string_t, bool_t>(tuple_t<bool_t, string_t>)>;
-    auto reverse_tuple_func = wasm_runtime_lookup_function(module_inst, "example:sample/tuples#reverse");
-    auto reverse_tuple_cleanup_func = wasm_runtime_lookup_function(module_inst, "cabi_post_example:sample/tuples#reverse");
-    reverse_tuple_func_t call_reverse_tuple = [&](tuple_t<bool_t, string_t> a) -> tuple_t<string_t, bool_t>
+    using lots_func_t = func_t<uint32_t(
+        string_t, string_t, string_t, string_t, string_t, string_t, string_t, string_t,
+        string_t, string_t, string_t, string_t, string_t, string_t, string_t, string_t, string_t)>;
+    auto lots_func = wasm_runtime_lookup_function(module_inst, "example:sample/strings#lots");
+    auto lots_cleanup_func = wasm_runtime_lookup_function(module_inst, "cabi_post_example:sample/strings#lots");
+    lots_func_t call_lots = [&](string_t p1, string_t p2, string_t p3, string_t p4, string_t p5, string_t p6, string_t p7, string_t p8,
+                                string_t p9, string_t p10, string_t p11, string_t p12, string_t p13, string_t p14, string_t p15, string_t p16, string_t p17) -> uint32_t
     {
-        using params_t = ValTrait<reverse_tuple_func_t>::params_t;
-        using results_t = ValTrait<reverse_tuple_func_t>::results_t;
+        auto flat_ft_lower = func::flatten<lots_func_t>(liftLowerContext, func::ContextType::Lower);
+        auto flat_ft_lift = func::flatten<lots_func_t>(liftLowerContext, func::ContextType::Lift);
 
-        auto inputs = toWamr(lower_flat_values(liftLowerContext, MAX_FLAT_PARAMS, params_t{a}));
-        auto output_size = 1;
-        wasm_val_t outputs[output_size];
-        auto call_result = wasm_runtime_call_wasm_a(exec_env, reverse_tuple_func, output_size, outputs, inputs.size(), inputs.data());
-        auto result = std::get<0>(lift_flat_values<results_t>(liftLowerContext, MAX_FLAT_RESULTS, fromWamr<results_t>(output_size, outputs)));
-        std::cout << "reverse_tuple(" << std::get<0>(a) << ", " << std::get<1>(a) << "): " << std::get<0>(result) << ", " << std::get<1>(result) << std::endl;
-        call_result = wasm_runtime_call_wasm_a(exec_env, reverse_tuple_cleanup_func, 0, nullptr, 1, outputs);
-        return result;
-    };
-    auto call_reverse_tuple_result = call_reverse_tuple({false, "Hello World!"});
-    // call_reverse_tuple({std::get<1>(call_reverse_tuple_result), std::get<0>(call_reverse_tuple_result}));
-
-    using list_filter_bool_func_t = func_t<list_t<string_t>(list_t<variant_t<bool_t, string_t>>)>;
-    auto list_filter_bool_func = wasm_runtime_lookup_function(module_inst, "example:sample/lists#filter-bool");
-    auto list_filter_bool_cleanup_func = wasm_runtime_lookup_function(module_inst, "cabi_post_example:sample/lists#filter-bool");
-    auto call_list_filter_bool = [&](list_t<variant_t<bool_t, string_t>> a) -> list_t<string_t>
-    {
-        using params_t = ValTrait<list_filter_bool_func_t>::params_t;
-        using results_t = ValTrait<list_filter_bool_func_t>::results_t;
+        using params_t = ValTrait<lots_func_t>::params_t;
+        using results_t = ValTrait<lots_func_t>::results_t;
 
-        auto inputs = toWamr(lower_flat_values(liftLowerContext, MAX_FLAT_PARAMS, params_t{a}));
+        auto inputs = toWamr(lower_flat_values<params_t>(liftLowerContext, MAX_FLAT_PARAMS, {p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15, p16, p17}));
+        auto inputs_size = inputs.size();
         auto output_size = 1;
         wasm_val_t outputs[output_size];
-        auto call_result = wasm_runtime_call_wasm_a(exec_env, list_filter_bool_func, output_size, outputs, inputs.size(), inputs.data());
+        auto call_result = wasm_runtime_call_wasm_a(exec_env, lots_func, output_size, outputs, inputs.size(), inputs.data());
         auto result = std::get<0>(lift_flat_values<results_t>(liftLowerContext, MAX_FLAT_RESULTS, fromWamr<results_t>(output_size, outputs)));
-        std::cout << "list_filter_bool(" << a.size() << "): " << result.size() << std::endl;
-        call_result = wasm_runtime_call_wasm_a(exec_env, list_filter_bool_cleanup_func, 0, nullptr, 1, outputs);
+        std::cout << "lots_string(" << p1 << ", " << p2 << ", " << p3 << ", " << p4 << ", " << p5 << ", " << p6 << ", " << p7 << ", " << p8
+                  << ", " << p9 << ", " << p10 << ", " << p11 << ", " << p12 << ", " << p13 << ", " << p14 << ", " << p15 << ", " << p16 << ", " << p17 << "): " << result << std::endl;
         return result;
     };
-    auto call_list_filter_bool_result = call_list_filter_bool({{false}, {"Hello World!"}});
+    auto call_lots_result = call_lots("p1", "p2", "p3", "p4", "p5", "p6", "p7", "p8", "p9", "p10", "p11", "p12", "p13", "p14", "p15", "p16", "p17");
+
+    // using reverse_tuple_func_t = func_t<tuple_t<string_t, bool_t>(tuple_t<bool_t, string_t>)>;
+    // auto reverse_tuple_func = wasm_runtime_lookup_function(module_inst, "example:sample/tuples#reverse");
+    // auto reverse_tuple_cleanup_func = wasm_runtime_lookup_function(module_inst, "cabi_post_example:sample/tuples#reverse");
+    // reverse_tuple_func_t call_reverse_tuple = [&](tuple_t<bool_t, string_t> a) -> tuple_t<string_t, bool_t>
+    // {
+    //     using params_t = ValTrait<reverse_tuple_func_t>::params_t;
+    //     using results_t = ValTrait<reverse_tuple_func_t>::results_t;
+
+    //     auto inputs = toWamr(lower_flat_values<params_t>(liftLowerContext, 100 + MAX_FLAT_PARAMS, {a}));
+    //     auto output_size = 1;
+    //     wasm_val_t outputs[output_size];
+    //     auto call_result = wasm_runtime_call_wasm_a(exec_env, reverse_tuple_func, output_size, outputs, inputs.size(), inputs.data());
+    //     auto result = std::get<0>(lift_flat_values<results_t>(liftLowerContext, MAX_FLAT_RESULTS, fromWamr<results_t>(output_size, outputs)));
+    //     std::cout << "reverse_tuple(" << std::get<0>(a) << ", " << std::get<1>(a) << "): " << std::get<0>(result) << ", " << std::get<1>(result) << std::endl;
+    //     call_result = wasm_runtime_call_wasm_a(exec_env, reverse_tuple_cleanup_func, 0, nullptr, 1, outputs);
+    //     return result;
+    // };
+    // auto call_reverse_tuple_result = call_reverse_tuple({false, "Hello World!"});
+    // // call_reverse_tuple({std::get<1>(call_reverse_tuple_result), std::get<0>(call_reverse_tuple_result}));
+
+    // using list_filter_bool_func_t = func_t<list_t<string_t>(list_t<variant_t<bool_t, string_t>>)>;
+    // auto list_filter_bool_func = wasm_runtime_lookup_function(module_inst, "example:sample/lists#filter-bool");
+    // auto list_filter_bool_cleanup_func = wasm_runtime_lookup_function(module_inst, "cabi_post_example:sample/lists#filter-bool");
+    // auto call_list_filter_bool = [&](list_t<variant_t<bool_t, string_t>> a) -> list_t<string_t>
+    // {
+    //     using params_t = ValTrait<list_filter_bool_func_t>::params_t;
+    //     using results_t = ValTrait<list_filter_bool_func_t>::results_t;
+
+    //     auto inputs = toWamr(lower_flat_values<params_t>(liftLowerContext, MAX_FLAT_PARAMS, {a}));
+    //     auto output_size = 1;
+    //     wasm_val_t outputs[output_size];
+    //     auto call_result = wasm_runtime_call_wasm_a(exec_env, list_filter_bool_func, output_size, outputs, inputs.size(), inputs.data());
+    //     auto result = std::get<0>(lift_flat_values<results_t>(liftLowerContext, MAX_FLAT_RESULTS, fromWamr<results_t>(output_size, outputs)));
+    //     std::cout << "list_filter_bool(" << a.size() << "): " << result.size() << std::endl;
+    //     call_result = wasm_runtime_call_wasm_a(exec_env, list_filter_bool_cleanup_func, 0, nullptr, 1, outputs);
+    //     return result;
+    // };
+    // auto call_list_filter_bool_result = call_list_filter_bool({{false}, {"Hello World!"}});
 
     wasm_runtime_destroy_exec_env(exec_env);
     wasm_runtime_deinstantiate(module_inst);

samples/wasm/main.cpp

@@ -1,6 +1,7 @@
 #include "sample.h"
 
 #include <cstdlib>
+#include <cstring>
 
 bool exports_example_sample_booleans_and(bool a, bool b)
 {
@@ -22,6 +23,13 @@ void exports_example_sample_strings_reverse(sample_string_t *a, sample_string_t
     }
 }
 
+uint32_t exports_example_sample_strings_lots(sample_string_t *p1, sample_string_t *p2, sample_string_t *p3, sample_string_t *p4, sample_string_t *p5, sample_string_t *p6, sample_string_t *p7, sample_string_t *p8, sample_string_t *p9, sample_string_t *p10, sample_string_t *p11, sample_string_t *p12, sample_string_t *p13, sample_string_t *p14, sample_string_t *p15, sample_string_t *p16, sample_string_t *p17)
+{
+    // Calculate total length
+    return p1->len + p2->len + p3->len + p4->len + p5->len + p6->len + p7->len + p8->len +
+           p9->len + p10->len + p11->len + p12->len + p13->len + p14->len + p15->len + p16->len + p17->len;
+}
+
 void exports_example_sample_tuples_reverse(sample_tuple2_bool_string_t *a, sample_tuple2_string_bool_t *ret)
 {
     ret->f1 = !a->f0;

samples/wasm/sample.wit

@@ -12,6 +12,12 @@ interface floats {
 
 interface strings {
   reverse: func(a: string) -> string;
+  lots: func(
+    p1: string, p2: string, p3: string, p4: string, p5: string,
+    p6: string, p7: string, p8: string, p9: string, p10: string,
+    p11: string, p12: string, p13: string, p14: string, p15: string,
+    p16: string, p17: string
+  ) -> u32;
 }
 
 interface tuples {