move felt divition to a mlir function

Author: FrancoGiachetta

.cargo/config.toml

@@ -0,0 +1,2 @@
+[install]
+root = "binaries/"

src/libfuncs/circuit.rs

@@ -608,6 +608,7 @@ fn build_gate_evaluation<'ctx, 'this>(
                         location,
                         rhs_value,
                         circuit_modulus_u768,
+                        u768_type
                     )?;
                     // Extract the values from the result struct
                     let gcd =

src/libfuncs/felt252.rs

@@ -2,8 +2,8 @@
 
 use super::LibfuncHelper;
 use crate::{
-    error::Result,
-    metadata::MetadataStorage,
+    error::{panic::ToNativeAssertError, Result},
+    metadata::{runtime_bindings::RuntimeBindingsMeta, MetadataStorage},
     utils::{ProgramRegistryExt, PRIME},
 };
 use cairo_lang_sierra::{
@@ -19,11 +19,8 @@ use cairo_lang_sierra::{
     program_registry::ProgramRegistry,
 };
 use melior::{
-    dialect::{
-        arith::{self, CmpiPredicate},
-        cf,
-    },
-    helpers::{ArithBlockExt, BuiltinBlockExt},
+    dialect::arith::{self, CmpiPredicate},
+    helpers::{ArithBlockExt, BuiltinBlockExt, LlvmBlockExt},
     ir::{r#type::IntegerType, Block, BlockLike, Location, Value, ValueLike},
     Context,
 };
@@ -149,80 +146,35 @@ pub fn build_binary_operation<'ctx, 'this>(
             entry.trunci(result, felt252_ty, location)?
         }
         Felt252BinaryOperator::Div => {
-            // The extended euclidean algorithm calculates the greatest common divisor of two integers,
-            // as well as the bezout coefficients x and y such that for inputs a and b, ax+by=gcd(a,b)
-            // We use this in felt division to find the modular inverse of a given number
-            // If a is the number we're trying to find the inverse of, we can do
-            // ax+y*PRIME=gcd(a,PRIME)=1 => ax = 1 (mod PRIME)
-            // Hence for input a, we return x
-            // The input MUST be non-zero
-            // See https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm
-            let start_block = helper.append_block(Block::new(&[(i512, location)]));
-            let loop_block = helper.append_block(Block::new(&[
-                (i512, location),
-                (i512, location),
-                (i512, location),
-                (i512, location),
-            ]));
-            let negative_check_block = helper.append_block(Block::new(&[]));
-            // Block containing final result
-            let inverse_result_block = helper.append_block(Block::new(&[(i512, location)]));
-            // Egcd works by calculating a series of remainders, each the remainder of dividing the previous two
-            // For the initial setup, r0 = PRIME, r1 = a
-            // This order is chosen because if we reverse them, then the first iteration will just swap them
-            let prev_remainder =
-                start_block.const_int_from_type(context, location, PRIME.clone(), i512)?;
-            let remainder = start_block.arg(0)?;
-            // Similarly we'll calculate another series which starts 0,1,... and from which we will retrieve the modular inverse of a
-            let prev_inverse = start_block.const_int_from_type(context, location, 0, i512)?;
-            let inverse = start_block.const_int_from_type(context, location, 1, i512)?;
-            start_block.append_operation(cf::br(
-                loop_block,
-                &[prev_remainder, remainder, prev_inverse, inverse],
-                location,
-            ));
-
-            //---Loop body---
-            // Arguments are rem_(i-1), rem, inv_(i-1), inv
-            let prev_remainder = loop_block.arg(0)?;
-            let remainder = loop_block.arg(1)?;
-            let prev_inverse = loop_block.arg(2)?;
-            let inverse = loop_block.arg(3)?;
-
-            // First calculate q = rem_(i-1)/rem_i, rounded down
-            let quotient =
-                loop_block.append_op_result(arith::divui(prev_remainder, remainder, location))?;
-            // Then r_(i+1) = r_(i-1) - q * r_i, and inv_(i+1) = inv_(i-1) - q * inv_i
-            let rem_times_quo = loop_block.muli(remainder, quotient, location)?;
-            let inv_times_quo = loop_block.muli(inverse, quotient, location)?;
-            let next_remainder = loop_block.append_op_result(arith::subi(
-                prev_remainder,
-                rem_times_quo,
-                location,
-            ))?;
-            let next_inverse =
-                loop_block.append_op_result(arith::subi(prev_inverse, inv_times_quo, location))?;
-
-            // If r_(i+1) is 0, then inv_i is the inverse
-            let zero = loop_block.const_int_from_type(context, location, 0, i512)?;
-            let next_remainder_eq_zero =
-                loop_block.cmpi(context, CmpiPredicate::Eq, next_remainder, zero, location)?;
-            loop_block.append_operation(cf::cond_br(
+            let runtime_bindings_meta = metadata
+                .get_mut::<RuntimeBindingsMeta>()
+                .to_native_assert_error(
+                    "Unable to get the RuntimeBindingsMeta from MetadataStorage",
+                )?;
+
+            let prime = entry.const_int_from_type(context, location, PRIME.clone(), i512)?;
+            let lhs = entry.extui(lhs, i512, location)?;
+            let rhs = entry.extui(rhs, i512, location)?;
+
+            // Find 1 / rhs.
+            let euclidean_result = runtime_bindings_meta.extended_euclidean_algorithm(
                 context,
-                next_remainder_eq_zero,
-                negative_check_block,
-                loop_block,
-                &[],
-                &[remainder, next_remainder, inverse, next_inverse],
+                helper.module,
+                entry,
                 location,
-            ));
+                rhs,
+                prime,
+                i512
+            )?;
+
+            let inverse = entry.extract_value(context, location, euclidean_result, i512, 1)?;
 
             // egcd sometimes returns a negative number for the inverse,
             // in such cases we must simply wrap it around back into [0, PRIME)
             // this suffices because |inv_i| <= divfloor(PRIME,2)
-            let zero = negative_check_block.const_int_from_type(context, location, 0, i512)?;
+            let zero = entry.const_int_from_type(context, location, 0, i512)?;
 
-            let is_negative = negative_check_block
+            let is_negative = entry
                 .append_operation(arith::cmpi(
                     context,
                     CmpiPredicate::Slt,
@@ -233,46 +185,30 @@ pub fn build_binary_operation<'ctx, 'this>(
                 .result(0)?
                 .into();
             // if the inverse is < 0, add PRIME
-            let prime =
-                negative_check_block.const_int_from_type(context, location, PRIME.clone(), i512)?;
-            let wrapped_inverse = negative_check_block.addi(inverse, prime, location)?;
-            let inverse = negative_check_block.append_op_result(arith::select(
+            let wrapped_inverse = entry.addi(inverse, prime, location)?;
+            let inverse = entry.append_op_result(arith::select(
                 is_negative,
                 wrapped_inverse,
                 inverse,
                 location,
             ))?;
-            negative_check_block.append_operation(cf::br(
-                inverse_result_block,
-                &[inverse],
-                location,
-            ));
 
-            // Div Logic Start
-            // Fetch operands
-            let lhs = entry.extui(lhs, i512, location)?;
-            let rhs = entry.extui(rhs, i512, location)?;
-            // Calculate inverse of rhs, callling the inverse implementation's starting block
-            entry.append_operation(cf::br(start_block, &[rhs], location));
-            // Fetch the inverse result from the result block
-            let inverse = inverse_result_block.arg(0)?;
-            // Peform lhs * (1/ rhs)
-            let result = inverse_result_block.muli(lhs, inverse, location)?;
+            // Peform lhs * (1 / rhs)
+            let result = entry.muli(lhs, inverse, location)?;
             // Apply modulo and convert result to felt252
-            let result_mod =
-                inverse_result_block.append_op_result(arith::remui(result, prime, location))?;
+            let result_mod = entry.append_op_result(arith::remui(result, prime, location))?;
             let is_out_of_range =
-                inverse_result_block.cmpi(context, CmpiPredicate::Uge, result, prime, location)?;
+                entry.cmpi(context, CmpiPredicate::Uge, result, prime, location)?;
 
-            let result = inverse_result_block.append_op_result(arith::select(
+            let result = entry.append_op_result(arith::select(
                 is_out_of_range,
                 result_mod,
                 result,
                 location,
             ))?;
-            let result = inverse_result_block.trunci(result, felt252_ty, location)?;
+            let result = entry.trunci(result, felt252_ty, location)?;
 
-            return helper.br(inverse_result_block, 0, &[result], location);
+            return helper.br(entry, 0, &[result], location);
         }
     };
 

src/metadata/runtime_bindings.rs

@@ -210,6 +210,7 @@ impl RuntimeBindingsMeta {
         location: Location<'c>,
         a: Value<'c, '_>,
         b: Value<'c, '_>,
+        integer_type: Type<'c>
     ) -> Result<Value<'c, 'a>>
     where
         'c: 'a,
@@ -219,9 +220,8 @@ impl RuntimeBindingsMeta {
             .active_map
             .insert(RuntimeBinding::ExtendedEuclideanAlgorithm)
         {
-            build_egcd_function(module, context, location, func_symbol)?;
+            build_egcd_function(module, context, location, func_symbol, integer_type)?;
         }
-        let integer_type: Type = IntegerType::new(context, 384 * 2).into();
         // The struct returned by the function that contains both of the results
         let return_type = llvm::r#type::r#struct(context, &[integer_type, integer_type], false);
         Ok(block
@@ -825,14 +825,24 @@ fn build_egcd_function<'ctx>(
     context: &'ctx Context,
     location: Location<'ctx>,
     func_symbol: &str,
+    integer_type: Type,
 ) -> Result<()> {
-    let integer_type: Type = IntegerType::new(context, 384 * 2).into();
     let region = Region::new();
 
     let entry_block = region.append_block(Block::new(&[
         (integer_type, location),
         (integer_type, location),
     ]));
+    let loop_block = region.append_block(Block::new(&[
+        (integer_type, location),
+        (integer_type, location),
+        (integer_type, location),
+        (integer_type, location),
+    ]));
+    let end_block = region.append_block(Block::new(&[
+        (integer_type, location),
+        (integer_type, location),
+    ]));
 
     let a = entry_block.arg(0)?;
     let b = entry_block.arg(1)?;
@@ -847,17 +857,6 @@ fn build_egcd_function<'ctx>(
     let prev_inverse = entry_block.const_int_from_type(context, location, 0, integer_type)?;
     let inverse = entry_block.const_int_from_type(context, location, 1, integer_type)?;
 
-    let loop_block = region.append_block(Block::new(&[
-        (integer_type, location),
-        (integer_type, location),
-        (integer_type, location),
-        (integer_type, location),
-    ]));
-    let end_block = region.append_block(Block::new(&[
-        (integer_type, location),
-        (integer_type, location),
-    ]));
-
     entry_block.append_operation(cf::br(
         &loop_block,
         &[prev_remainder, remainder, prev_inverse, inverse],