compiler: reorg intermediate representation

Author: tcoratger

crates/lean_compiler/src/a_simplify_lang.rs

@@ -1,6 +1,6 @@
 use crate::{
     Counter, F,
-    intermediate_bytecode::HighLevelOperation,
+    ir::HighLevelOperation,
     lang::{
         Boolean, ConstExpression, ConstMallocLabel, Expression, Function, Line, Program,
         SimpleExpr, Var,

crates/lean_compiler/src/b_compile_intermediate.rs

@@ -1,4 +1,4 @@
-use crate::{F, a_simplify_lang::*, intermediate_bytecode::*, lang::*, precompiles::*};
+use crate::{F, a_simplify_lang::*, ir::*, lang::*, precompiles::*};
 use lean_vm::*;
 use p3_field::Field;
 use std::{

crates/lean_compiler/src/c_compile_final.rs

@@ -1,4 +1,4 @@
-use crate::{F, PUBLIC_INPUT_START, ZERO_VEC_PTR, intermediate_bytecode::*, lang::*};
+use crate::{F, PUBLIC_INPUT_START, ZERO_VEC_PTR, ir::*, lang::*};
 use lean_vm::*;
 use p3_field::{PrimeCharacteristicRing, PrimeField32};
 use std::collections::BTreeMap;

crates/lean_compiler/src/ir/bytecode.rs

@@ -0,0 +1,51 @@
+use std::collections::BTreeMap;
+use std::fmt::{Display, Formatter, Result as FmtResult};
+use super::instruction::IntermediateInstruction;
+use lean_vm::Label;
+
+/// Container for the complete intermediate representation of a program.
+///
+/// This structure holds all the compiled intermediate bytecode along with
+/// metadata needed for execution and analysis.
+#[derive(Debug, Clone)]
+pub struct IntermediateBytecode {
+    /// Main bytecode organized by function labels.
+    ///
+    /// Each label corresponds to a function entry point.
+    pub bytecode: BTreeMap<Label, Vec<IntermediateInstruction>>,
+
+    /// Match statement bytecode blocks.
+    ///
+    /// Each match statement produces multiple case blocks.
+    pub match_blocks: Vec<Vec<Vec<IntermediateInstruction>>>,
+
+    /// Memory requirements for each function.
+    ///
+    /// Maps function names to their stack frame size.
+    pub memory_size_per_function: BTreeMap<String, usize>,
+}
+
+impl Display for IntermediateBytecode {
+    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
+        for (label, instructions) in &self.bytecode {
+            writeln!(f, "\n{label}:")?;
+            for instruction in instructions {
+                writeln!(f, "  {instruction}")?;
+            }
+        }
+        for (i, match_blocks) in self.match_blocks.iter().enumerate() {
+            writeln!(f, "\nMatch {i}:")?;
+            for (j, case) in match_blocks.iter().enumerate() {
+                writeln!(f, "  Case {j}:")?;
+                for instruction in case {
+                    writeln!(f, "    {instruction}")?;
+                }
+            }
+        }
+        writeln!(f, "\nMemory size per function:")?;
+        for (function_name, size) in &self.memory_size_per_function {
+            writeln!(f, "{function_name}: {size}")?;
+        }
+        Ok(())
+    }
+}