Use cranelift vars instead of stack slots

2 files changed, 11 insertions, 44 deletions

diff --git a/patio-to-cranelift/src/codegen/context.rs b/patio-to-cranelift/src/codegen/context.rs
index 213e1a6f..4d87adcf 100644
--- a/patio-to-cranelift/src/codegen/context.rs
+++ b/patio-to-cranelift/src/codegen/context.rs
@@ -100,8 +100,6 @@ impl CompilerContext {
             target_triple: self.target_triple.clone(),
             var_name_to_variable: Default::default(),
             var_name_to_type: Default::default(),
-            stack_slot_name_to_stack_slot: Default::default(),
-            stack_slot_name_to_type: Default::default(),
         };
         generate_function_body(&mut context);
 
@@ -158,8 +156,6 @@ pub(crate) struct CompilerFunctionContext<'a> {
     pub(crate) target_triple: target_lexicon::Triple,
     var_name_to_variable: HashMap<String, cranelift::prelude::Variable>,
     var_name_to_type: HashMap<String, cranelift_codegen::ir::Type>,
-    stack_slot_name_to_stack_slot: HashMap<String, cranelift_codegen::ir::StackSlot>,
-    stack_slot_name_to_type: HashMap<String, cranelift_codegen::ir::Type>,
 }
 
 impl<'a> CompilerFunctionContext<'a> {
@@ -183,30 +179,6 @@ impl<'a> CompilerFunctionContext<'a> {
         self.var_name_to_type[name]
     }
 
-    pub(crate) fn create_stack_slot(&mut self, name: &str, type_: cranelift_codegen::ir::Type) {
-        let stack_slot =
-            self.function_builder
-                .create_sized_stack_slot(cranelift::prelude::StackSlotData {
-                    kind: cranelift::prelude::StackSlotKind::ExplicitSlot,
-                    size: type_.bytes(),
-                    // TODO: alignment
-                    align_shift: 0,
-                    key: None,
-                });
-
-        self.stack_slot_name_to_stack_slot
-            .insert(name.to_string(), stack_slot);
-        self.stack_slot_name_to_type.insert(name.to_string(), type_);
-    }
-
-    pub(crate) fn stack_slot(&mut self, name: &str) -> cranelift_codegen::ir::StackSlot {
-        self.stack_slot_name_to_stack_slot[name]
-    }
-
-    pub(crate) fn stack_slot_type(&mut self, name: &str) -> cranelift_codegen::ir::Type {
-        self.stack_slot_name_to_type[name]
-    }
-
     pub(crate) fn data_ptr(&mut self, name: &str) -> cranelift_codegen::ir::GlobalValue {
         let data_id = match self.module.declarations().get_name(name) {
             Some(cranelift_module::FuncOrDataId::Data(data_id)) => data_id,
diff --git a/patio-to-cranelift/src/codegen/mod.rs b/patio-to-cranelift/src/codegen/mod.rs
index 83422307..6ce8a2c5 100644
--- a/patio-to-cranelift/src/codegen/mod.rs
+++ b/patio-to-cranelift/src/codegen/mod.rs
@@ -212,7 +212,7 @@ fn define_function_definition(
                             local.type_,
                             &function_context.target_triple,
                         );
-                        function_context.create_stack_slot(&local.name, cranelift_type);
+                        function_context.declare_var(&local.name, cranelift_type);
                     }
                 }
             }
@@ -643,24 +643,19 @@ fn compile_switch(switch: &PatioSwitch, context: &mut CompilerFunctionContext<'_
 }
 
 fn compile_var_load(var_load: &PatioVarLoad, context: &mut CompilerFunctionContext<'_>) {
-    let stack_slot = context.stack_slot(&var_load.var.name);
-    let type_ = context.stack_slot_type(&var_load.var.name);
-    let value = context.function_builder.ins().stack_load(
-        type_,
-        stack_slot,
-        cranelift_codegen::ir::immediates::Offset32::new(0),
-    );
-    def_destination(&var_load.destination, value, context);
+    let cranelift_variable = context.var(&var_load.var.name);
+    let cranelift_value = context.function_builder.use_var(cranelift_variable);
+
+    def_destination(&var_load.destination, cranelift_value, context);
 }
 
 fn compile_var_store(var_store: &PatioVarStore, context: &mut CompilerFunctionContext<'_>) {
-    let stack_slot = context.stack_slot(&var_store.var.name);
-    let value = compile_operand(&var_store.value, context);
-    context.function_builder.ins().stack_store(
-        value,
-        stack_slot,
-        cranelift_codegen::ir::immediates::Offset32::new(0),
-    );
+    let cranelift_variable = context.var(&var_store.var.name);
+    let cranelift_value = compile_operand(&var_store.value, context);
+
+    context
+        .function_builder
+        .def_var(cranelift_variable, cranelift_value);
 }
 
 fn compile_operands<'a>(