Merge pull request #11 from lambdaclass/impl-signed-libfuncs

implement some signed int libfuncts
lambdaclass · Oct 7, 2024 · 40ee994 · 40ee994
2 parents 2b612d5 + 734b341
commit 40ee994
Show file tree

Hide file tree

Showing 9 changed files with 328 additions and 4 deletions.
diff --git a/Cargo.toml b/Cargo.toml
@@ -4,6 +4,8 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+cairo-lang-compiler = "2.8.2"
+cairo-lang-filesystem = "2.8.2"
 cairo-lang-sierra = "2.8.0"
 cairo-lang-sierra-ap-change = "2.8.0"
 cairo-lang-sierra-gas = "2.8.0"
@@ -23,6 +25,7 @@ smallvec = "1.13.2"
 starknet-crypto = "0.7.1"
 starknet-curve = "0.5.0"
 starknet-types-core = "0.1.2"
+tempfile = "3.13.0"
 thiserror = "1.0.63"
 tracing = "0.1.40"
 tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }

diff --git a/src/lib.rs b/src/lib.rs
@@ -6,6 +6,7 @@ mod debug;
 mod dump;
 mod gas;
 pub mod starknet;
+mod test_utils;
 mod value;
 mod vm;
 

diff --git a/src/test_utils.rs b/src/test_utils.rs
@@ -0,0 +1,105 @@
+use std::{fs, path::Path, sync::Arc};
+
+use cairo_lang_compiler::{
+    compile_prepared_db, db::RootDatabase, diagnostics::DiagnosticsReporter,
+    project::setup_project, CompilerConfig,
+};
+use cairo_lang_filesystem::db::init_dev_corelib;
+use cairo_lang_sierra::{
+    extensions::{
+        circuit::CircuitTypeConcrete, core::CoreTypeConcrete, starknet::StarkNetTypeConcrete,
+    },
+    program::Program,
+};
+
+use crate::{find_entry_point_by_idx, ProgramTrace, StateDump, Value, VirtualMachine};
+
+#[macro_export]
+macro_rules! load_cairo {
+    ( $( $program:tt )+ ) => {
+        $crate::test_utils::load_cairo_from_str(stringify!($($program)+))
+    };
+}
+
+pub(crate) fn load_cairo_from_str(cairo_str: &str) -> (String, Program) {
+    let mut file = tempfile::Builder::new()
+        .prefix("test_")
+        .suffix(".cairo")
+        .tempfile()
+        .unwrap();
+    let mut db = RootDatabase::default();
+
+    fs::write(&mut file, cairo_str).unwrap();
+
+    init_dev_corelib(
+        &mut db,
+        Path::new(&std::env::var("CARGO_MANIFEST_DIR").unwrap()).join("corelib/src"),
+    );
+
+    let main_crate_ids = setup_project(&mut db, file.path()).unwrap();
+
+    let sierra_with_dbg = compile_prepared_db(
+        &db,
+        main_crate_ids,
+        CompilerConfig {
+            diagnostics_reporter: DiagnosticsReporter::stderr(),
+            replace_ids: true,
+            ..Default::default()
+        },
+    )
+    .unwrap();
+
+    let module_name = file.path().with_extension("");
+    let module_name = module_name.file_name().unwrap().to_str().unwrap();
+    (module_name.to_string(), sierra_with_dbg.program)
+}
+
+pub fn run_test_program(sierra_program: Program) -> Vec<Value> {
+    let function = find_entry_point_by_idx(&sierra_program, 0).unwrap();
+
+    let mut vm = VirtualMachine::new(Arc::new(sierra_program.clone()));
+
+    let initial_gas = 1000000;
+
+    vm.push_frame(
+        function.id.clone(),
+        function
+            .signature
+            .param_types
+            .iter()
+            .map(|type_id| {
+                let type_info = vm.registry().get_type(type_id).unwrap();
+                match type_info {
+                    CoreTypeConcrete::GasBuiltin(_) => crate::Value::U128(initial_gas),
+                    CoreTypeConcrete::StarkNet(StarkNetTypeConcrete::System(_)) => Value::Unit,
+                    CoreTypeConcrete::RangeCheck(_)
+                    | CoreTypeConcrete::RangeCheck96(_)
+                    | CoreTypeConcrete::Pedersen(_)
+                    | CoreTypeConcrete::Poseidon(_)
+                    | CoreTypeConcrete::Bitwise(_)
+                    | CoreTypeConcrete::BuiltinCosts(_)
+                    | CoreTypeConcrete::SegmentArena(_)
+                    | CoreTypeConcrete::Circuit(
+                        CircuitTypeConcrete::AddMod(_) | CircuitTypeConcrete::MulMod(_),
+                    ) => Value::Unit,
+                    _ => unreachable!(),
+                }
+            })
+            .collect::<Vec<_>>(),
+    );
+
+    let mut trace = ProgramTrace::new();
+
+    while let Some((statement_idx, state)) = vm.step() {
+        trace.push(StateDump::new(statement_idx, state));
+    }
+
+    trace
+        .states
+        .last()
+        .unwrap()
+        .items
+        .values()
+        .cloned()
+        .collect()
+}
diff --git a/src/value.rs b/src/value.rs
@@ -52,6 +52,8 @@ pub enum Value {
         x1: Felt,
         y1: Felt,
     },
+    I128(i128),
+    I32(i32),
     I8(i8),
     Struct(Vec<Self>),
     U256(u128, u128),
@@ -105,6 +107,8 @@ impl Value {
             }
             CoreTypeConcrete::GasBuiltin(_) => matches!(self, Self::U128(_)),
             CoreTypeConcrete::NonZero(info) => self.is(registry, &info.ty),
+            CoreTypeConcrete::Sint128(_) => matches!(self, Self::I128(_)),
+            CoreTypeConcrete::Sint32(_) => matches!(self, Self::I32(_)),
             CoreTypeConcrete::Sint8(_) => matches!(self, Self::I8(_)),
             CoreTypeConcrete::Snapshot(info) => self.is(registry, &info.ty),
             CoreTypeConcrete::StarkNet(
@@ -154,9 +158,7 @@ impl Value {
             CoreTypeConcrete::Uint64(_) => matches!(self, Self::U64(_)),
             CoreTypeConcrete::Uint128MulGuarantee(_) => matches!(self, Self::Unit),
             CoreTypeConcrete::Sint16(_) => todo!(),
-            CoreTypeConcrete::Sint32(_) => todo!(),
             CoreTypeConcrete::Sint64(_) => todo!(),
-            CoreTypeConcrete::Sint128(_) => todo!(),
             CoreTypeConcrete::Nullable(info) => self.is(registry, &info.ty),
             CoreTypeConcrete::Uninitialized(_) => todo!(),
             CoreTypeConcrete::Felt252DictEntry(_) => todo!(),

diff --git a/src/vm.rs b/src/vm.rs
@@ -40,6 +40,7 @@ mod felt252_dict;
 mod felt252_dict_entry;
 mod function_call;
 mod gas;
+mod int128;
 mod jump;
 mod mem;
 mod pedersen;
@@ -331,7 +332,7 @@ fn eval<'a>(
         CoreConcreteLibfunc::Nullable(_) => todo!(),
         CoreConcreteLibfunc::Pedersen(selector) => self::pedersen::eval(registry, selector, args),
         CoreConcreteLibfunc::Poseidon(selector) => self::poseidon::eval(registry, selector, args),
-        CoreConcreteLibfunc::Sint128(_) => todo!(),
+        CoreConcreteLibfunc::Sint128(selector) => self::int128::eval(registry, selector, args),
         CoreConcreteLibfunc::Sint16(_) => todo!(),
         CoreConcreteLibfunc::Sint32(_) => todo!(),
         CoreConcreteLibfunc::Sint64(_) => todo!(),

diff --git a/src/vm/cast.rs b/src/vm/cast.rs
@@ -50,6 +50,7 @@ pub fn eval_downcast(
                 range_check,
                 match registry.get_type(&info.to_ty).unwrap() {
                     CoreTypeConcrete::Sint8(_) => Value::I8(value.try_into().unwrap()),
+                    CoreTypeConcrete::Sint128(_) => Value::I128(value.try_into().unwrap()),
                     CoreTypeConcrete::Uint8(_) => Value::U8(value.try_into().unwrap()),
                     CoreTypeConcrete::Uint16(_) => Value::U16(value.try_into().unwrap()),
                     CoreTypeConcrete::Uint32(_) => Value::U32(value.try_into().unwrap()),
@@ -89,6 +90,8 @@ pub fn eval_upcast(
             .unwrap()
         {
             CoreTypeConcrete::Sint8(_) => Value::I8(value.try_into().unwrap()),
+            CoreTypeConcrete::Sint32(_) => Value::I32(value.try_into().unwrap()),
+            CoreTypeConcrete::Sint128(_) => Value::I128(value.try_into().unwrap()),
             CoreTypeConcrete::Uint8(_) => Value::U8(value.try_into().unwrap()),
             CoreTypeConcrete::Uint16(_) => Value::U16(value.try_into().unwrap()),
             CoreTypeConcrete::Uint32(_) => Value::U32(value.try_into().unwrap()),

diff --git a/src/vm/const.rs b/src/vm/const.rs
@@ -56,10 +56,22 @@ pub fn eval_as_immediate(
                 _ => unreachable!(),
             },
             CoreTypeConcrete::NonZero(info) => inner(registry, &info.ty, inner_data),
+            CoreTypeConcrete::Sint128(_) => match inner_data {
+                [GenericArg::Value(value)] => Value::I128(value.try_into().unwrap()),
+                _ => unreachable!(),
+            },
+            CoreTypeConcrete::Sint32(_) => match inner_data {
+                [GenericArg::Value(value)] => Value::I32(value.try_into().unwrap()),
+                _ => unreachable!(),
+            },
             CoreTypeConcrete::Sint8(_) => match inner_data {
                 [GenericArg::Value(value)] => Value::I8(value.try_into().unwrap()),
                 _ => unreachable!(),
             },
+            CoreTypeConcrete::Uint64(_) => match inner_data {
+                [GenericArg::Value(value)] => Value::U64(value.try_into().unwrap()),
+                _ => unreachable!(),
+            },
             CoreTypeConcrete::Uint32(_) => match inner_data {
                 [GenericArg::Value(value)] => Value::U32(value.try_into().unwrap()),
                 _ => unreachable!(),
@@ -95,7 +107,7 @@ pub fn eval_as_immediate(
 
                 Value::Struct(fields)
             }
-            _ => todo!("{:?}", type_id),
+            _ => todo!("{}", type_id),
         }
     }