Initial commit

Author: fegge

.gitignore

@@ -0,0 +1 @@
+/target

Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "miden-decompiler"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+clap = { version = "4.5", features = ["derive"] }
+miden-assembly-syntax = { version = "0.20", default-features = false, features = ["std", "arbitrary"] }

src/analysis/mod.rs

@@ -0,0 +1,7 @@
+//! Analysis passes (expression propagation, DCE, etc.).
+//!
+//! This module currently only contains placeholders to keep the crate layout close to `rewasm`.
+
+/// Placeholder result type for future analysis passes.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct AnalysisState;

src/callgraph/mod.rs

@@ -0,0 +1,99 @@
+use std::collections::HashMap;
+
+use miden_assembly_syntax::ast::{path::PathBuf as MasmPathBuf, Invoke, InvokeKind, InvocationTarget};
+
+use crate::frontend::{Program, Workspace};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum CallTarget {
+    Direct(String),
+    Opaque,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct CallEdge {
+    pub kind: InvokeKind,
+    pub target: CallTarget,
+}
+
+#[derive(Debug, Clone)]
+pub struct ProcNode {
+    pub name: String,
+    pub module_path: MasmPathBuf,
+    pub edges: Vec<CallEdge>,
+}
+
+#[derive(Debug, Default)]
+pub struct CallGraph {
+    pub nodes: Vec<ProcNode>,
+    pub name_to_id: HashMap<String, usize>,
+}
+
+impl CallGraph {
+    pub fn build(program: &Program) -> Self {
+        let mut graph = CallGraph::default();
+        for (idx, proc) in program.procedures().enumerate() {
+            let module_path = program.module_path().clone();
+            let module_path_str = <MasmPathBuf as AsRef<str>>::as_ref(&module_path);
+            let name = format!("{}::{}", module_path_str, proc.name().as_str());
+            let edges = proc
+                .invoked()
+                .map(|invoke| edge_from_invoke(invoke, program))
+                .collect();
+            graph.name_to_id.insert(name.clone(), idx);
+            graph.nodes.push(ProcNode { name, module_path, edges });
+        }
+        graph
+    }
+
+    pub fn build_for_workspace(ws: &Workspace) -> Self {
+        let mut graph = CallGraph::default();
+        for prog in ws.modules() {
+            let module_path = prog.module_path().clone();
+            let module_path_str = <MasmPathBuf as AsRef<str>>::as_ref(&module_path);
+            for proc in prog.procedures() {
+                let name = format!("{}::{}", module_path_str, proc.name().as_str());
+                let idx = graph.nodes.len();
+                graph.name_to_id.insert(name.clone(), idx);
+                let edges = proc
+                    .invoked()
+                    .map(|invoke| edge_from_invoke(invoke, prog))
+                    .collect();
+                graph.nodes.push(ProcNode {
+                    name,
+                    module_path: module_path.clone(),
+                    edges,
+                });
+            }
+        }
+        graph
+    }
+}
+
+fn edge_from_invoke(invoke: &Invoke, program: &Program) -> CallEdge {
+    CallEdge {
+        kind: invoke.kind,
+        target: match &invoke.target {
+            InvocationTarget::Symbol(name) => CallTarget::Direct(format!(
+                "{}::{}",
+                <MasmPathBuf as AsRef<str>>::as_ref(program.module_path()),
+                name.as_str()
+            )),
+            InvocationTarget::Path(path) => CallTarget::Direct(path.to_string()),
+            InvocationTarget::MastRoot(_) => CallTarget::Opaque,
+        },
+    }
+}
+
+pub trait EdgeTargetString {
+    fn target_string(&self) -> String;
+}
+
+impl EdgeTargetString for CallEdge {
+    fn target_string(&self) -> String {
+        match &self.target {
+            CallTarget::Direct(s) => s.clone(),
+            CallTarget::Opaque => "__opaque__".to_string(),
+        }
+    }
+}

src/cfg/mod.rs

@@ -0,0 +1,54 @@
+//! Control-flow graph structures.
+//!
+//! These mirror the `rewasm` layout but are trimmed down until stack/SSA plumbing lands.
+
+use crate::ssa::Stmt;
+
+pub type NodeId = usize;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct InstrPos {
+    pub node: NodeId,
+    pub instr: usize,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum EdgeType {
+    Unconditional,
+    Conditional(bool),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct EdgeCond {
+    pub expr_index: u32,
+    pub edge_type: EdgeType,
+}
+
+impl EdgeCond {
+    pub const fn unconditional() -> Self {
+        Self {
+            expr_index: 0,
+            edge_type: EdgeType::Unconditional,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Edge {
+    pub cond: EdgeCond,
+    pub node: NodeId,
+    pub back_edge: bool,
+}
+
+#[derive(Debug, Default)]
+pub struct BasicBlock {
+    pub code: Vec<Stmt>,
+    pub next: Vec<Edge>,
+    pub prev: Vec<Edge>,
+}
+
+/// Skeleton CFG used until the builder/structuring passes are in place.
+#[derive(Debug, Default)]
+pub struct Cfg {
+    pub nodes: Vec<BasicBlock>,
+}

src/fmt/mod.rs

@@ -0,0 +1,34 @@
+//! Pretty-printing helpers.
+//!
+//! This will grow to match the `rewasm` `fmt` module; for now it just exposes a stub writer.
+
+use crate::ssa::Stmt;
+
+#[derive(Default)]
+pub struct CodeWriter {
+    output: String,
+    indent: usize,
+}
+
+impl CodeWriter {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn write_stmt(&mut self, stmt: &Stmt) {
+        self.output.push_str(&format!("{:?}", stmt));
+        self.output.push('\n');
+    }
+
+    pub fn indent(&mut self) {
+        self.indent += 1;
+    }
+
+    pub fn dedent(&mut self) {
+        self.indent = self.indent.saturating_sub(1);
+    }
+
+    pub fn finish(self) -> String {
+        self.output
+    }
+}

src/frontend/mod.rs

@@ -0,0 +1,135 @@
+//! Frontend: parse MASM source into an AST module plus lightweight metadata.
+
+use std::path::{Path as FsPath, PathBuf as FsPathBuf};
+
+use miden_assembly_syntax::{
+    ast::{path::PathBuf as MasmPathBuf, Module, ModuleKind, Procedure},
+    debuginfo::DefaultSourceManager,
+    ModuleParser, Report,
+};
+use std::sync::Arc;
+
+/// A library root maps a namespace (e.g. "std") to a filesystem directory.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct LibraryRoot {
+    pub namespace: String,
+    pub path: FsPathBuf,
+}
+
+impl LibraryRoot {
+    pub fn new(namespace: impl Into<String>, path: FsPathBuf) -> Self {
+        Self {
+            namespace: namespace.into(),
+            path,
+        }
+    }
+}
+
+/// Parsed MASM module plus its filesystem origin.
+#[derive(Debug)]
+pub struct Program {
+    module: Box<Module>,
+    source_path: FsPathBuf,
+    module_path: MasmPathBuf,
+}
+
+impl Program {
+    pub fn from_path(path: impl AsRef<FsPath>, roots: &[LibraryRoot]) -> Result<Self, Report> {
+        let path = path.as_ref();
+        let mut parser = ModuleParser::new(ModuleKind::Executable);
+
+        let module_name = derive_module_path(path, roots)
+            .unwrap_or_else(|_| MasmPathBuf::absolute(Module::ROOT));
+
+        let source_manager: Arc<dyn miden_assembly_syntax::debuginfo::SourceManager> =
+            Arc::new(DefaultSourceManager::default());
+        let module = parser.parse_file(&module_name, path, source_manager)?;
+
+        Ok(Self {
+            module,
+            source_path: path.to_path_buf(),
+            module_path: module_name,
+        })
+    }
+
+    /// Construct a program from an already-parsed module and explicit metadata.
+    pub fn from_parts(module: Box<Module>, source_path: FsPathBuf, module_path: MasmPathBuf) -> Self {
+        Self {
+            module,
+            source_path,
+            module_path,
+        }
+    }
+
+    pub fn module(&self) -> &Module {
+        &self.module
+    }
+
+    pub fn source_path(&self) -> &FsPathBuf {
+        &self.source_path
+    }
+
+    pub fn module_path(&self) -> &MasmPathBuf {
+        &self.module_path
+    }
+
+    pub fn procedures(&self) -> impl Iterator<Item = &Procedure> {
+        self.module.procedures()
+    }
+}
+
+mod workspace;
+pub use workspace::Workspace;
+pub mod testing;
+
+/// Derive a MASM module path (e.g. `std::math::u64`) from a filesystem path and library roots.
+///
+/// Roots are searched in order; the first that contains `file_path` is used. If no root matches,
+/// returns an error.
+pub fn derive_module_path(
+    file_path: &FsPath,
+    roots: &[LibraryRoot],
+) -> Result<MasmPathBuf, String> {
+    let file_name = file_path
+        .file_name()
+        .and_then(|f| f.to_str())
+        .ok_or_else(|| "module path derivation failed: missing file name".to_string())?;
+    let is_mod = file_name == "mod.masm";
+
+    for root in roots {
+        if let Ok(rel) = file_path.strip_prefix(&root.path) {
+            let mut comps: Vec<String> = Vec::new();
+            if !root.namespace.is_empty() {
+                comps.push(root.namespace.clone());
+            }
+
+            let mut parts: Vec<String> = rel
+                .components()
+                .map(|c| c.as_os_str().to_string_lossy().into_owned())
+                .collect();
+            if parts.is_empty() {
+                continue;
+            }
+
+            let file_part = parts.pop().unwrap();
+            let stem = if is_mod {
+                parts.pop().unwrap_or_else(|| "mod".to_string())
+            } else {
+                FsPath::new(&file_part)
+                    .file_stem()
+                    .and_then(|s| s.to_str())
+                    .map(|s| s.to_string())
+                    .ok_or_else(|| "invalid file stem".to_string())?
+            };
+
+            comps.extend(parts);
+            comps.push(stem);
+
+            let path_str = comps.join("::");
+            return MasmPathBuf::new(&path_str)
+                .map_err(|e| format!("invalid module path {path_str}: {e}"));
+        }
+    }
+
+    Err("module path derivation failed: file not under any library root".to_string())
+}

src/frontend/testing.rs

@@ -0,0 +1,27 @@
+use std::path::PathBuf;
+
+use miden_assembly_syntax::{
+    ast::{path::PathBuf as MasmPathBuf, Module, ModuleKind},
+    debuginfo::{DefaultSourceManager, SourceManager},
+    ModuleParser,
+};
+use std::sync::Arc;
+
+use super::{LibraryRoot, Program, Workspace};
+
+/// Build a workspace from in-memory modules specified as (module_path, source).
+pub fn workspace_from_modules(mods: &[(&str, &str)]) -> Workspace {
+    let mut ws = Workspace::new(vec![LibraryRoot::new("", PathBuf::from("."))]);
+    for (path, source) in mods {
+        let module_path =
+            MasmPathBuf::new(path).unwrap_or_else(|_| MasmPathBuf::absolute(Module::ROOT));
+        let mut parser = ModuleParser::new(ModuleKind::Library);
+        let source_manager: Arc<dyn SourceManager> = Arc::new(DefaultSourceManager::default());
+        let module =
+            parser.parse_str(module_path.clone(), *source, source_manager).expect("parse");
+        let program =
+            Program::from_parts(module, PathBuf::from(format!("{path}.masm")), module_path);
+        ws.add_program(program);
+    }
+    ws
+}