WIP: harm runtime

harm-runtime/Cargo.toml

@@ -12,4 +12,9 @@ publish = false
 
 [dependencies]
 harm = { workspace = true }
-memmap2 = "0.9.9"
+memmap2 = { version = "0.9.9", optional = true }
+thiserror = "2.0.18"
+
+[features]
+default = ["memmap2"]
+memmap2 = ["dep:memmap2"]

harm-runtime/src/labels.rs

@@ -3,11 +3,93 @@
  * This document is licensed under the BSD 3-clause license.
  */
 
-use harm::reloc::Offset;
+use std::collections::HashMap;
+
+use harm::reloc::{LabelId, Offset};
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub enum LabelInfo {
     Forward,
     // TODO segment
     Offset(Offset),
 }
+
+#[derive(Debug, Default)]
+pub struct LabelRegistry {
+    named_labels: HashMap<String, LabelId>,
+    labels: HashMap<LabelId, LabelInfo>,
+    next_id: usize,
+}
+
+impl LabelRegistry {
+    #[inline]
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    #[inline]
+    pub fn forward_named_label(&mut self, name: &str) -> LabelId {
+        if let Some(id) = self.named_labels.get(name) {
+            *id
+        } else {
+            let id = self.next_label();
+            self.named_labels.insert(name.to_string(), id);
+            self.labels.insert(id, LabelInfo::Forward);
+            id
+        }
+    }
+
+    #[inline]
+    pub fn forward_label(&mut self) -> LabelId {
+        let id = self.next_label();
+        self.labels.insert(id, LabelInfo::Forward);
+        id
+    }
+
+    pub fn define_label(&mut self, label_id: LabelId, offset: Offset) {
+        if let Some(info) = self.labels.get_mut(&label_id) {
+            match info {
+                LabelInfo::Forward => {
+                    *info = LabelInfo::Offset(offset);
+                }
+                LabelInfo::Offset(_) => {
+                    todo!("Label {label_id:?} is already defined");
+                }
+            }
+        } else {
+            panic!("Label {label_id:?} is not registered");
+        }
+    }
+
+    #[inline]
+    pub fn define_named_label(&mut self, name: &str, offset: Offset) -> LabelId {
+        if let Some(id) = self.named_labels.get(name).copied() {
+            self.labels.insert(id, LabelInfo::Offset(offset));
+            id
+        } else {
+            let id = self.next_label();
+            self.named_labels.insert(name.to_string(), id);
+            self.labels.insert(id, LabelInfo::Offset(offset));
+            id
+        }
+    }
+
+    pub fn name_label(&mut self, id: LabelId, name: &str) {
+        if self.labels.contains_key(&id) {
+            self.named_labels.insert(name.to_string(), id);
+        } else {
+            panic!("Label {id:?} is not registered");
+        }
+    }
+
+    #[inline]
+    pub fn label_info(&self, id: LabelId) -> Option<&LabelInfo> {
+        self.labels.get(&id)
+    }
+
+    fn next_label(&mut self) -> LabelId {
+        let id = LabelId(self.next_id);
+        self.next_id += 1;
+        id
+    }
+}

harm-runtime/src/lib.rs

@@ -4,3 +4,5 @@
  */
 
 pub mod labels;
+pub mod memory;
+pub mod runtime;

harm-runtime/src/memory.rs

@@ -0,0 +1,72 @@
+/* Copyright (C) 2026 Ivan Boldyrev
+ *
+ * This document is licensed under the BSD 3-clause license.
+ */
+
+#[cfg(feature = "memmap2")]
+mod memmap2;
+
+#[cfg(feature = "memmap2")]
+pub use self::memmap2::{Mmap2Buffer, Mmap2FixedMemory};
+
+pub trait Memory<FM: FixedMemory> {
+    type ExtendError;
+    type FixedMemoryError;
+
+    /// Current writing position.
+    fn pos(&self) -> usize;
+
+    /// If memory has fixed capacity, return it.
+    ///
+    /// A `Vec` is not considered a memory of fixed capacity because it can grow indefinitely.
+    fn capacity(&self) -> Option<usize>;
+
+    /// Append data to the memory.  Should fail when it reaches memory's capacity.
+    fn try_extend<I: Iterator<Item = u8>>(&mut self, bytes: I) -> Result<(), Self::ExtendError>;
+
+    /// Transform into fixed-location memory.
+    fn into_fixed_memory(self) -> Result<FM, Self::FixedMemoryError>;
+
+    /// Align position.
+    fn align(&mut self, alignment: usize) -> Result<(), Self::ExtendError> {
+        let pos = self.pos();
+        let remn = pos % alignment;
+        if remn != 0 {
+            self.try_extend(core::iter::repeat(0).take(alignment - remn))?;
+        }
+        Ok(())
+    }
+}
+
+/// Memory with fixed location that can be transformed to an executable one after relocations are applied.
+pub trait FixedMemory: AsMut<[u8]> {
+    type ExecutableMemory;
+    type ExecutableMemoryError;
+
+    fn into_executable_memory(self) -> Result<Self::ExecutableMemory, Self::ExecutableMemoryError>;
+}
+
+#[cfg(test)]
+mod tests {
+    #[cfg(feature = "memmap2")]
+    #[test]
+    fn test_align() {
+        use super::*;
+
+        let mut data = Vec::<u8>::new();
+
+        Memory::align(&mut data, 8);
+        assert!(data.is_empty());
+
+        data.push(1);
+        Memory::align(&mut data, 8);
+        assert_eq!(data.len(), 8);
+
+        Memory::align(&mut data, 8);
+        assert_eq!(data.len(), 8);
+
+        data.extend_from_slice(&[1, 2, 3, 4, 5, 6, 7]);
+        Memory::align(&mut data, 8);
+        assert_eq!(data.len(), 16);
+    }
+}