wasm backend struggles

crates/compiler/gen_wasm/src/low_level.rs

@@ -11,7 +11,7 @@ use roc_mono::low_level::HigherOrder;
 
 use crate::backend::{ProcLookupData, ProcSource, WasmBackend};
 use crate::layout::{CallConv, StackMemoryFormat, WasmLayout};
-use crate::storage::{AddressValue, StackMemoryLocation, StoredValue};
+use crate::storage::{AddressValue, StackMemoryLocation, StoredValue, StoredVarKind};
 use crate::PTR_TYPE;
 use roc_wasm_module::{Align, LocalId, ValueType};
 
@@ -1960,9 +1960,81 @@ impl<'a> LowLevelCall<'a> {
                 backend.storage.load_symbols(code_builder, self.arguments);
             }
 
-            PtrStore => todo!("{:?}", self.lowlevel),
-            PtrLoad => todo!("{:?}", self.lowlevel),
-            PtrToStackValue => todo!("{:?}", self.lowlevel),
+            PtrStore => {
+                // PtrStore : Ptr a, a -> {}
+                let ptr_sym = self.arguments[0];
+                let value_sym = self.arguments[1];
+                let layout = self.ret_layout;
+
+                // create a local variable for the heap pointer
+                let ptr_local_id = match backend.storage.ensure_value_has_local(
+                    &mut backend.code_builder,
+                    ptr_sym,
+                    self.ret_storage.clone(),
+                ) {
+                    StoredValue::Local { local_id, .. } => local_id,
+                    StoredValue::StackMemory { location, .. } => {
+                        location
+                            .local_and_offset(backend.storage.stack_frame_pointer)
+                            .0
+                    }
+                    other => internal_error!(
+                        "Struct should be allocated in stack memory, but it's in {:?}",
+                        other
+                    ),
+                };
+
+                dbg!(ptr_local_id);
+
+                // store the pointer value from the value stack into the local variable
+                backend.code_builder.set_local(ptr_local_id);
+
+                // copy the argument to the pointer address
+                backend.storage.copy_value_to_memory(
+                    &mut backend.code_builder,
+                    ptr_local_id,
+                    0,
+                    value_sym,
+                );
+            }
+            PtrLoad => backend.expr_unbox(self.ret_symbol, self.arguments[0]),
+            PtrToStackValue => {
+                let arg = self.arguments[0];
+                let arg_layout = backend.storage.symbol_layouts.get(&arg).unwrap();
+
+                let (size, alignment_bytes) = backend
+                    .layout_interner
+                    .stack_size_and_alignment(*arg_layout);
+
+                let (frame_ptr, offset) = backend
+                    .storage
+                    .allocate_anonymous_stack_memory(size, alignment_bytes);
+
+                backend.storage.copy_value_to_memory(
+                    &mut backend.code_builder,
+                    frame_ptr,
+                    offset,
+                    arg,
+                );
+
+                // create a local variable for the pointer
+                let ptr_local_id = match backend.storage.ensure_value_has_local(
+                    &mut backend.code_builder,
+                    self.ret_symbol,
+                    self.ret_storage.clone(),
+                ) {
+                    StoredValue::Local { local_id, .. } => local_id,
+                    _ => internal_error!("A pointer will always be an i32"),
+                };
+
+                // store the pointer value from the value stack into the local variable
+                dbg!(offset, size, alignment_bytes);
+
+                backend.code_builder.get_local(frame_ptr);
+                backend.code_builder.i32_const(offset as i32);
+                backend.code_builder.i32_add();
+                backend.code_builder.set_local(ptr_local_id);
+            }
 
             Hash => todo!("{:?}", self.lowlevel),