Printing felt representation of types (currently on top of #65)

benches/execution.rs

@@ -1,4 +1,4 @@
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::fs;
 use std::path::Path;
 
@@ -13,6 +13,7 @@ use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
 use inkwell::execution_engine::ExecutionEngine;
 use inkwell::OptimizationLevel;
 use shenlong_core::sierra::llvm_compiler::{CompilationState, Compiler, DebugCompiler};
+use shenlong_core::sierra::process::dataflow::DataFlowGraph;
 
 pub fn criterion_benchmark(c: &mut Criterion) {
     benchmark_llvm(c, "core/tests/test_data/sierra/fib_bench.sierra");
@@ -55,23 +56,23 @@ fn benchmark_llvm(c: &mut Criterion, file_path: &str) {
         context: &context,
         builder: &builder,
         module,
-        variables: HashMap::new(),
         llvm_output_path: Path::new("").to_path_buf(),
         state: CompilationState::NotStarted,
         valid_state_transitions: Compiler::init_state_transitions(),
         types_by_id: HashMap::new(),
         types_by_name: HashMap::new(),
-        basic_blocks: HashMap::new(),
-        jump_dests: HashSet::new(),
+        enum_packing_index_by_name: HashMap::new(),
+        dataflow_graph: DataFlowGraph::new(),
         user_functions: HashMap::new(),
         debug,
     };
 
     compiler.setup_debug().unwrap();
     compiler.process_types().unwrap();
     compiler.process_core_lib_functions().unwrap();
-    compiler.collect_jumps();
     compiler.process_funcs().unwrap();
+    compiler.process_dataflow().unwrap();
+    compiler.process_statements().unwrap();
     let execution_engine = compiler.module.create_jit_execution_engine(OptimizationLevel::Aggressive).unwrap();
     c.bench_with_input(BenchmarkId::new("Llvm", 1), &(execution_engine), |b, execution_engine| {
         b.iter(|| {

core/Cargo.toml

@@ -13,15 +13,22 @@ cairo-lang-sierra = { git = "https://github.com/starkware-libs/cairo", branch =
 env_logger = "0.10.0"
 tempdir = "0.3.7"
 num-bigint = "0.4"
+num-traits = "0.2.15"
 thiserror = "1.0.38"
 test-case = "3.0.0"
 tracing = "0.1.37"
 regex = "1.7.1"
+num-integer = "0.1.45"
+itertools = "0.10.5"
 
 [dev-dependencies]
+anyhow = "1.0.66"
+cairo-lang-compiler = { git = "https://github.com/starkware-libs/cairo", branch = "main" }
+cairo-lang-diagnostics = { git = "https://github.com/starkware-libs/cairo", branch = "main" }
+cairo-lang-runner = { git = "https://github.com/starkware-libs/cairo", branch = "main" }
+cairo-lang-sierra-generator = { git = "https://github.com/starkware-libs/cairo", branch = "main" }
 pretty_assertions = "1.3.0"
 proptest = "1.1.0"
 tinytemplate = "1.2.1"
 serde = { version = "1.0.152", features = ["derive"] }
 num-bigint = "0.4.3"
-num-traits = "0.2.15"

core/src/sierra/corelib_functions/enums/enum_init.rs

@@ -0,0 +1,86 @@
+use cairo_lang_sierra::ids::ConcreteTypeId;
+use cairo_lang_sierra::program::{GenericArg, LibfuncDeclaration};
+use num_traits::ToPrimitive;
+
+use crate::sierra::errors::DEBUG_NAME_EXPECTED;
+use crate::sierra::llvm_compiler::Compiler;
+
+impl<'a, 'ctx> Compiler<'a, 'ctx> {
+    /// Implementation of the LLVM IR conversion of an enum initialisation operation.
+    ///
+    /// # Arguments
+    ///
+    /// * `libfunc_declaration` - The corelib function declaration of `enum_init<T>`.
+    ///
+    /// # Error
+    ///
+    /// Panics if the type T has not been declared previously as all types should be declared at the
+    /// beginning of the sierra file.
+    /// Panics if the sierra file doesn't have the debug infos.
+    pub fn enum_init(&mut self, libfunc_declaration: &LibfuncDeclaration) {
+        // Type of the enum that we have to construct.
+        let func_name = libfunc_declaration.id.debug_name.as_ref().expect(DEBUG_NAME_EXPECTED).as_str();
+        let (full_enum_type_id, enum_type_name) = match &libfunc_declaration.long_id.generic_args[0] {
+            GenericArg::Type(ConcreteTypeId { id, debug_name }) => {
+                (id, debug_name.clone().expect(DEBUG_NAME_EXPECTED).to_string())
+            }
+            _val => {
+                panic!("Enum init only takes predefined enums")
+            }
+        };
+        let enum_index_type_name = format!("ut@{}", enum_type_name);
+        let enum_index_parameter = match &libfunc_declaration.long_id.generic_args[1] {
+            GenericArg::Value(val) => val.to_usize().unwrap(),
+            _ => {
+                panic!("Enum init only takes predefined enums")
+            }
+        };
+        let enum_index_type = self.types_by_name.get(&enum_index_type_name).unwrap().into_int_type();
+        let return_type = self.types_by_id.get(full_enum_type_id).unwrap().into_struct_type();
+
+        // Find the location in the struct representation at which the payload is held
+        let data_offset = self
+            .enum_packing_index_by_name
+            .get(&enum_type_name)
+            .expect("Enum data packing locations should have been registered before processing of enum_init")
+            [enum_index_parameter];
+
+        let input_type = return_type.get_field_type_at_index(data_offset as u32).unwrap();
+        let debug_arg_type = self.debug.struct_types_by_id.get(full_enum_type_id).unwrap()[data_offset];
+        let debug_return_type = *self.debug.types_by_id.get(full_enum_type_id).unwrap();
+
+        // fn enum_init<T, i>(T[i]) -> T
+        // which is to say that to construct an enum we only need input for the value that's actually stored
+        let func = self.module.add_function(func_name, return_type.fn_type(&[input_type.into()], false), None);
+
+        let debug_func = self.debug.create_function(func_name, &func, Some(debug_return_type), &[debug_arg_type], None);
+
+        self.builder.position_at_end(self.context.append_basic_block(func, "entry"));
+        // Allocate memory for the enum on the stack.
+        let enum_ptr = self.builder.build_alloca(return_type, "res_ptr");
+        // Store the index in the struct
+        let index_to_store = enum_index_type.const_int(enum_index_parameter as u64, false);
+        let ptr_to_index = self.builder.build_struct_gep(return_type, enum_ptr, 0u32, "index_ptr").unwrap();
+        self.builder.build_store(ptr_to_index, index_to_store);
+        // Store the payload in the struct
+        let value_to_store = func.get_first_param().expect("enum_init should have one parameter");
+        let ptr_to_member =
+            self.builder.build_struct_gep(return_type, enum_ptr, data_offset as u32, "member_ptr").unwrap();
+        self.builder.build_store(ptr_to_member, value_to_store);
+
+        // Finally, return the enum
+        // Could potentially return the pointer here, likely won't make much difference though
+        self.builder.build_return(Some(&self.builder.build_load(return_type, enum_ptr, "res")));
+
+        // // Debug values
+        for (i, (value, arg_ty)) in func.get_params().iter().zip([debug_arg_type]).enumerate() {
+            let debug_local_var = self.debug.create_local_variable(&i.to_string(), debug_func.scope, arg_ty, None);
+            self.debug.insert_dbg_value(
+                *value,
+                debug_local_var,
+                self.builder.get_current_debug_location().unwrap(),
+                func.get_first_basic_block().unwrap().get_first_instruction().unwrap(),
+            );
+        }
+    }
+}

core/src/sierra/corelib_functions/enums/mod.rs

@@ -0,0 +1,2 @@
+mod enum_init;
+// no enum match here, handled in statements_processing

core/src/sierra/corelib_functions/mod.rs

@@ -1,5 +1,5 @@
 pub mod boxes;
-pub mod functions;
+pub mod enums;
 pub mod math;
 pub mod memory;
 pub mod structs;