[Serra-Emu] Fix some libfuncs

.github/workflows/ci.yml

@@ -361,10 +361,9 @@ jobs:
     - name: Run tests
       working-directory: ./debug_utils/sierra-emu
       run: make test-no-corelib
-    - name: Run corelib's tests (WIP)
+    - name: Run corelib's tests
       working-directory: ./debug_utils/sierra-emu
       run: cargo test test_corelib -- --nocapture
-      continue-on-error: true # ignore result for now. When sierra-emu is fully implemented this should be removed
 
   build-sierra2casm-dbg:
     name: Build sierra2casm-dbg

debug_utils/sierra-emu/src/lib.rs

@@ -10,6 +10,7 @@ use cairo_lang_sierra::{
     program::{GenFunction, Program, StatementIdx},
     program_registry::ProgramRegistry,
 };
+use debug::type_to_name;
 use starknet::StubSyscallHandler;
 
 pub use self::{dump::*, gas::BuiltinCosts, value::*, vm::VirtualMachine};
@@ -132,7 +133,8 @@ pub fn run_program(
                         }
                         _ => todo!(),
                     },
-                    _ => todo!(),
+                    CoreTypeConcrete::EcOp(_) => Value::Unit,
+                    _ => todo!("{}", type_to_name(type_id, vm.registry())),
                 }
             })
             .collect::<Vec<_>>(),

debug_utils/sierra-emu/src/utils.rs

@@ -3,13 +3,14 @@ use cairo_lang_sierra::{
         core::{CoreLibfunc, CoreType, CoreTypeConcrete},
         utils::Range,
     },
+    ids::ConcreteTypeId,
     program_registry::ProgramRegistry,
 };
 use num_bigint::BigInt;
 use num_traits::{Bounded, One, ToPrimitive};
 use starknet_types_core::felt::CAIRO_PRIME_BIGINT;
 
-use crate::Value;
+use crate::{debug::type_to_name, Value};
 
 /// Receives a vector of values, filters any which is non numeric and returns a `Vec<BigInt>`
 /// Useful when a binary operation takes generic values (like with bounded ints).
@@ -29,21 +30,20 @@ pub fn get_numeric_args_as_bigints(args: &[Value]) -> Vec<BigInt> {
             Value::U128(value) => BigInt::from(*value),
             Value::Felt(value) => value.to_bigint(),
             Value::Bytes31(value) => value.to_bigint(),
-            value => panic!("argument should be an integer: {:?}", value),
+            value => panic!("Argument should be an integer: {:?}", value),
         })
         .collect()
 }
 
 pub fn get_value_from_integer(
     registry: &ProgramRegistry<CoreType, CoreLibfunc>,
-    ty: &CoreTypeConcrete,
+    ty_id: &ConcreteTypeId,
     value: BigInt,
 ) -> Value {
+    let ty = registry.get_type(ty_id).unwrap();
+
     match ty {
-        CoreTypeConcrete::NonZero(info) => {
-            let ty = registry.get_type(&info.ty).unwrap();
-            get_value_from_integer(registry, ty, value)
-        }
+        CoreTypeConcrete::NonZero(info) => get_value_from_integer(registry, &info.ty, value),
         CoreTypeConcrete::Sint8(_) => Value::I8(value.to_i8().unwrap()),
         CoreTypeConcrete::Sint16(_) => Value::I16(value.to_i16().unwrap()),
         CoreTypeConcrete::Sint32(_) => Value::I32(value.to_i32().unwrap()),
@@ -62,12 +62,15 @@ pub fn get_value_from_integer(
             }
         }
         CoreTypeConcrete::Felt252(_) => Value::Felt(value.into()),
-        _ => panic!("cannot get integer value for a non-integer type"),
+        _ => panic!(
+            "Cannot get integer value for a non-integer type: {}",
+            type_to_name(ty_id, registry)
+        ),
     }
 }
 
 pub fn integer_range(
-    ty: &CoreTypeConcrete,
+    ty_id: &ConcreteTypeId,
     registry: &ProgramRegistry<CoreType, CoreLibfunc>,
 ) -> Range {
     fn range_of<T>() -> Range
@@ -80,6 +83,8 @@ pub fn integer_range(
         }
     }
 
+    let ty = registry.get_type(ty_id).unwrap();
+
     match ty {
         CoreTypeConcrete::Uint8(_) => range_of::<u8>(),
         CoreTypeConcrete::Uint16(_) => range_of::<u16>(),
@@ -100,14 +105,11 @@ pub fn integer_range(
             lower: BigInt::ZERO,
             upper: BigInt::one() << 248,
         },
-        CoreTypeConcrete::Const(info) => {
-            let ty = registry.get_type(&info.inner_ty).unwrap();
-            integer_range(ty, registry)
-        }
-        CoreTypeConcrete::NonZero(info) => {
-            let ty = registry.get_type(&info.ty).unwrap();
-            integer_range(ty, registry)
-        }
-        _ => panic!("cannot get integer range value for a non-integer type"),
+        CoreTypeConcrete::Const(info) => integer_range(&info.inner_ty, registry),
+        CoreTypeConcrete::NonZero(info) => integer_range(&info.ty, registry),
+        _ => panic!(
+            "Cannot get integer range value for a non-integer type {}",
+            type_to_name(ty_id, registry)
+        ),
     }
 }

debug_utils/sierra-emu/src/value.rs

@@ -101,13 +101,17 @@ impl Value {
                 index: 0,
                 payload: Box::new(Value::default_for_type(registry, &info.variants[0])),
             },
+            CoreTypeConcrete::Array(info) => Value::Array {
+                ty: info.ty.clone(),
+                data: vec![],
+            },
             CoreTypeConcrete::Struct(info) => Value::Struct(
                 info.members
                     .iter()
                     .map(|member| Value::default_for_type(registry, member))
                     .collect(),
             ),
-            CoreTypeConcrete::Nullable(info) => Value::default_for_type(registry, &info.ty),
+            CoreTypeConcrete::Nullable(_) => Value::Null,
             x => panic!("type {:?} has no default value implementation", x.info()),
         }
     }

debug_utils/sierra-emu/src/vm.rs

@@ -471,7 +471,6 @@ fn eval<'a>(
         CoreConcreteLibfunc::Circuit(selector) => self::circuit::eval(registry, selector, args),
         CoreConcreteLibfunc::Const(selector) => self::r#const::eval(registry, selector, args),
         CoreConcreteLibfunc::Coupon(selector) => self::coupon::eval(registry, selector, args),
-        CoreConcreteLibfunc::CouponCall(_) => todo!(),
         CoreConcreteLibfunc::Debug(_) => todo!(),
         CoreConcreteLibfunc::Drop(info) => self::drop::eval(registry, info, args),
         CoreConcreteLibfunc::Dup(info) => self::dup::eval(registry, info, args),
@@ -484,7 +483,12 @@ fn eval<'a>(
         CoreConcreteLibfunc::Felt252DictEntry(selector) => {
             self::felt252_dict_entry::eval(registry, selector, args)
         }
-        CoreConcreteLibfunc::FunctionCall(info) => self::function_call::eval(registry, info, args),
+        CoreConcreteLibfunc::FunctionCall(info) => {
+            self::function_call::eval_function_call(registry, info, args)
+        }
+        CoreConcreteLibfunc::CouponCall(info) => {
+            self::function_call::eval_coupon_call(registry, info, args)
+        }
         CoreConcreteLibfunc::Gas(selector) => {
             self::gas::eval(registry, selector, args, gas, *statement_idx, builtin_costs)
         }

debug_utils/sierra-emu/src/vm/array.rs

@@ -297,13 +297,10 @@ fn eval_snapshot_multi_pop_back(
     };
 
     if data.len() >= popped_cty.members.len() {
-        let new_data = data.split_off(data.len() - popped_cty.members.len());
-        let value = Value::Struct(data);
+        let popped_data = data.split_off(data.len() - popped_cty.members.len());
+        let value = Value::Struct(popped_data);
         assert!(value.is(registry, &info.popped_ty));
-        EvalAction::NormalBranch(
-            0,
-            smallvec![rangecheck, Value::Array { data: new_data, ty }, value],
-        )
+        EvalAction::NormalBranch(0, smallvec![rangecheck, Value::Array { data, ty }, value])
     } else {
         EvalAction::NormalBranch(1, smallvec![rangecheck, Value::Array { data, ty }])
     }

debug_utils/sierra-emu/src/vm/bounded_int.rs

@@ -1,5 +1,8 @@
 use super::EvalAction;
-use crate::{utils::get_numeric_args_as_bigints, Value};
+use crate::{
+    utils::{get_numeric_args_as_bigints, get_value_from_integer},
+    Value,
+};
 use cairo_lang_sierra::{
     extensions::{
         bounded_int::{
@@ -126,8 +129,10 @@ pub fn eval_div_rem(
     info: &BoundedIntDivRemConcreteLibfunc,
     args: Vec<Value>,
 ) -> EvalAction {
-    let [lhs, rhs]: [BigInt; 2] = get_numeric_args_as_bigints(&args).try_into().unwrap();
-
+    let range_check @ Value::Unit: Value = args[0].clone() else {
+        panic!()
+    };
+    let [lhs, rhs]: [BigInt; 2] = get_numeric_args_as_bigints(&args[1..]).try_into().unwrap();
     let quo = &lhs / &rhs;
     let rem = lhs % rhs;
 
@@ -151,7 +156,7 @@ pub fn eval_div_rem(
     EvalAction::NormalBranch(
         0,
         smallvec![
-            Value::Unit, // range_check
+            range_check,
             Value::BoundedInt {
                 range: quo_range,
                 value: quo,
@@ -169,14 +174,10 @@ pub fn eval_constrain(
     info: &BoundedIntConstrainConcreteLibfunc,
     args: Vec<Value>,
 ) -> EvalAction {
-    let [range_check @ Value::Unit, value]: [Value; 2] = args.try_into().unwrap() else {
+    let range_check @ Value::Unit: Value = args[0].clone() else {
         panic!()
     };
-
-    let value = match value {
-        Value::I8(value) => value.into(),
-        _ => todo!(),
-    };
+    let [value]: [BigInt; 1] = get_numeric_args_as_bigints(&args[1..]).try_into().unwrap();
 
     if value < info.boundary {
         let range = match registry
@@ -224,19 +225,19 @@ pub fn eval_constrain(
 }
 
 pub fn eval_is_zero(
-    _registry: &ProgramRegistry<CoreType, CoreLibfunc>,
-    _info: &SignatureOnlyConcreteLibfunc,
+    registry: &ProgramRegistry<CoreType, CoreLibfunc>,
+    info: &SignatureOnlyConcreteLibfunc,
     args: Vec<Value>,
 ) -> EvalAction {
-    let [value] = args.try_into().unwrap();
-    let is_zero = match value {
-        Value::I8(value) => value == 0,
-        _ => todo!(),
-    };
+    let [value] = get_numeric_args_as_bigints(&args).try_into().unwrap();
+    let is_zero = value == 0.into();
+
+    let int_ty = &info.branch_signatures()[1].vars[0].ty;
 
     if is_zero {
         EvalAction::NormalBranch(0, smallvec![])
     } else {
+        let value = get_value_from_integer(registry, int_ty, value);
         EvalAction::NormalBranch(1, smallvec![value])
     }
 }

debug_utils/sierra-emu/src/vm/cast.rs

@@ -35,13 +35,15 @@ fn eval_downcast(
     };
     let [value] = get_numeric_args_as_bigints(&args[1..]).try_into().unwrap();
 
-    let int_ty = registry.get_type(&info.to_ty).unwrap();
-
     let range = info.to_range.lower.clone()..info.to_range.upper.clone();
+
     if range.contains(&value) {
         EvalAction::NormalBranch(
             0,
-            smallvec![range_check, get_value_from_integer(registry, int_ty, value)],
+            smallvec![
+                range_check,
+                get_value_from_integer(registry, &info.to_ty, value)
+            ],
         )
     } else {
         EvalAction::NormalBranch(1, smallvec![range_check])
@@ -54,12 +56,10 @@ fn eval_upcast(
     args: Vec<Value>,
 ) -> EvalAction {
     let [value] = get_numeric_args_as_bigints(&args).try_into().unwrap();
-    let int_ty = registry
-        .get_type(&info.branch_signatures()[0].vars[0].ty)
-        .unwrap();
+    let int_ty_id = &info.branch_signatures()[0].vars[0].ty;
 
     EvalAction::NormalBranch(
         0,
-        smallvec![get_value_from_integer(registry, int_ty, value)],
+        smallvec![get_value_from_integer(registry, int_ty_id, value)],
     )
 }

debug_utils/sierra-emu/src/vm/function_call.rs

@@ -8,7 +8,7 @@ use cairo_lang_sierra::{
     program_registry::ProgramRegistry,
 };
 
-pub fn eval(
+pub fn eval_function_call(
     registry: &ProgramRegistry<CoreType, CoreLibfunc>,
     info: &SignatureAndFunctionConcreteLibfunc,
     args: Vec<Value>,
@@ -21,3 +21,20 @@ pub fn eval(
 
     EvalAction::FunctionCall(info.function.id.clone(), args.into_iter().collect())
 }
+
+pub fn eval_coupon_call(
+    registry: &ProgramRegistry<CoreType, CoreLibfunc>,
+    info: &SignatureAndFunctionConcreteLibfunc,
+    mut args: Vec<Value>,
+) -> EvalAction {
+    // Don't check the last arg since it is not actually an argument for the function call itself
+    assert_eq!(args.len() - 1, info.function.params.len());
+    assert!(args
+        .iter()
+        .zip(&info.function.params)
+        .all(|(value, param)| value.is(registry, &param.ty)));
+
+    args.pop();
+
+    EvalAction::FunctionCall(info.function.id.clone(), args.into_iter().collect())
+}