intermediate bytecode: implement to_bytecode

Author: tcoratger

crates/leanVm/src/bytecode/hint.rs

@@ -42,6 +42,13 @@ pub enum Hint {
         /// A list of memory locations or constants whose values should be printed.
         content: Vec<MemOrConstant>,
     },
+    /// A hint for the prover to compute the modular inverse of a field element.
+    Inverse {
+        /// The value to be inverted.
+        arg: MemOrConstant,
+        /// The offset from `fp` where the result (`arg^-1`) will be stored. If `arg` is zero, zero is stored.
+        res_offset: usize,
+    },
 }
 
 impl Hint {
@@ -119,6 +126,21 @@ impl Hint {
                         .insert(((run_context.fp + *res_offset)? + i)?, bit)?;
                 }
             }
+            Self::Inverse { arg, res_offset } => {
+                // Resolve the `arg` operand to a concrete field element.
+                let value: F = run_context
+                    .value_from_mem_or_constant(arg, memory_manager)?
+                    .try_into()?;
+
+                // Compute the modular inverse. If the value is zero, the result is zero.
+                let result = value.try_inverse().unwrap_or(F::ZERO);
+
+                // Compute the destination address: `fp + res_offset`.
+                let res_addr = (run_context.fp + *res_offset)?;
+
+                // Write the result to the destination address in memory.
+                memory_manager.memory.insert(res_addr, result)?;
+            }
             Self::Print { .. } => {
                 // TODO: implement
                 // This is for debugging purposes only so this is not urgent for now.

crates/leanVm/src/bytecode/operand.rs

@@ -31,6 +31,16 @@ impl MemOrConstant {
             Self::MemoryAfterFp { offset } => (F::from_usize(*offset), F::ZERO),
         }
     }
+
+    /// Returns a constant operand with value `0`.
+    #[must_use] pub const fn zero() -> Self {
+        Self::Constant(F::ZERO)
+    }
+
+    /// Returns a constant operand with value `1`.
+    #[must_use] pub const fn one() -> Self {
+        Self::Constant(F::ONE)
+    }
 }
 
 /// Represents a value that can be a memory location, the `fp` register itself, or a constant.

crates/leanVm/src/compiler/mod.rs

@@ -0,0 +1,9 @@
+use std::collections::BTreeMap;
+
+use crate::lang::Label;
+
+#[derive(Debug)]
+pub struct Compiler {
+    pub memory_size_per_function: BTreeMap<String, usize>,
+    pub label_to_pc: BTreeMap<Label, usize>,
+}

crates/leanVm/src/intermediate_bytecode/instruction.rs

@@ -116,7 +116,7 @@ impl IntermediateInstruction {
         }
     }
 
-    pub fn is_hint(&self) -> bool {
+    #[must_use] pub const fn is_hint(&self) -> bool {
         match self {
             Self::RequestMemory { .. }
             | Self::Print { .. }

crates/leanVm/src/intermediate_bytecode/intermediate_value.rs

@@ -1,6 +1,11 @@
 use std::fmt;
 
-use crate::lang::{ConstExpression, Label};
+use crate::{
+    bytecode::operand::{MemOrConstant, MemOrFp},
+    compiler::Compiler,
+    constant::F,
+    lang::{ConstExpression, Label},
+};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum IntermediateValue {
@@ -19,6 +24,37 @@ impl IntermediateValue {
     pub const fn is_constant(&self) -> bool {
         matches!(self, Self::Constant(_))
     }
+
+    pub fn try_into_mem_or_fp(&self, compiler: &Compiler) -> Result<MemOrFp, String> {
+        match self {
+            Self::MemoryAfterFp { offset } => Ok(MemOrFp::MemoryAfterFp {
+                offset: offset.eval_const_expression_usize(compiler),
+            }),
+            Self::Fp => Ok(MemOrFp::Fp),
+            Self::Constant(_) => Err(format!("Cannot convert {self:?} to MemOrFp")),
+        }
+    }
+
+    pub fn try_into_mem_or_constant(&self, compiler: &Compiler) -> Result<MemOrConstant, String> {
+        if let Some(cst) = self.try_as_constant(compiler) {
+            return Ok(MemOrConstant::Constant(cst));
+        }
+        if let Self::MemoryAfterFp { offset } = self {
+            return Ok(MemOrConstant::MemoryAfterFp {
+                offset: offset.eval_const_expression_usize(compiler),
+            });
+        }
+        Err(format!("Cannot convert {self:?} to MemOrConstant"))
+    }
+
+    #[must_use]
+    pub fn try_as_constant(&self, compiler: &Compiler) -> Option<F> {
+        if let Self::Constant(c) = self {
+            Some(c.eval_const_expression(compiler))
+        } else {
+            None
+        }
+    }
 }
 
 impl From<ConstExpression> for IntermediateValue {