State representation.

lib/runtime-core/src/backend.rs

@@ -4,6 +4,7 @@ use crate::{
     typed_func::Wasm,
     types::{LocalFuncIndex, SigIndex},
     vm,
+    state::FunctionStateMap,
 };
 
 use crate::{
@@ -84,6 +85,11 @@ pub trait RunnableModule: Send + Sync {
         local_func_index: LocalFuncIndex,
     ) -> Option<NonNull<vm::Func>>;
 
+    fn get_func_statemap(
+        &self,
+        _local_func_index: LocalFuncIndex,
+    ) -> Option<FunctionStateMap> { None }
+
     /// A wasm trampoline contains the necesarry data to dynamically call an exported wasm function.
     /// Given a particular signature index, we are returned a trampoline that is matched with that
     /// signature and an invoke function that can call the trampoline.

lib/runtime-core/src/lib.rs

@@ -43,6 +43,7 @@ pub mod vm;
 pub mod vmcalls;
 #[cfg(all(unix, target_arch = "x86_64"))]
 pub use trampoline_x64 as trampoline;
+pub mod state;
 
 use self::error::CompileResult;
 #[doc(inline)]

lib/runtime-core/src/state.rs

@@ -0,0 +1,75 @@
+#[derive(Copy, Clone, Debug)]
+pub struct RegisterIndex(pub usize);
+
+#[derive(Clone, Debug, Default)]
+pub struct FunctionStateMap {
+    pub local_to_locations: Vec<Location>,
+    pub diffs: Vec<StateDiff>,
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct StateDiff {
+    pub last: Option<usize>,
+    pub stack_to_locations_push: Vec<Location>,
+    pub stack_to_locations_pop: usize,
+}
+
+#[derive(Clone, Debug)]
+pub enum Location {
+    Virtual, // no physical storage
+    Memory(RegisterIndex, i32),
+    Register(RegisterIndex),
+}
+
+#[cfg(all(unix, target_arch = "x86_64"))]
+pub mod x64 {
+    use super::*;
+
+    #[repr(u8)]
+    #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+    pub enum GPR {
+        RAX,
+        RCX,
+        RDX,
+        RBX,
+        RSP,
+        RBP,
+        RSI,
+        RDI,
+        R8,
+        R9,
+        R10,
+        R11,
+        R12,
+        R13,
+        R14,
+        R15,
+    }
+
+    #[repr(u8)]
+    #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+    pub enum XMM {
+        XMM0,
+        XMM1,
+        XMM2,
+        XMM3,
+        XMM4,
+        XMM5,
+        XMM6,
+        XMM7,
+    }
+
+    pub enum X64Register {
+        GPR(GPR),
+        XMM(XMM),
+    }
+
+    impl X64Register {
+        pub fn to_index(&self) -> RegisterIndex {
+            match *self {
+                X64Register::GPR(x) => RegisterIndex(x as usize),
+                X64Register::XMM(x) => RegisterIndex(x as usize + 1000),
+            }
+        }
+    }
+}