[core] Add tracer runtime

Cargo.lock

@@ -646,7 +646,6 @@ dependencies = [
 name = "nac3artiq"
 version = "0.1.0"
 dependencies = [
- "indexmap 2.7.1",
  "itertools",
  "nac3core",
  "nac3ld",

flake.nix

@@ -113,8 +113,8 @@
             (pkgs.fetchFromGitHub {
               owner = "m-labs";
               repo = "artiq";
-              rev = "554b0749ca5985bf4d006c4f29a05e83de0a226d";
-              sha256 = "sha256-3eSNHTSlmdzLMcEMIspxqjmjrcQe4aIGqIfRgquUg18=";
+              rev = "28c9de3e251daa89a8c9fd79d5ab64a3ec03bac6";
+              sha256 = "sha256-vAvpbHc5B+1wtG8zqN7j9dQE1ON+i22v+uqA+tw6Gak=";
             })
           ];
           buildInputs = [

nac3artiq/Cargo.toml

@@ -9,7 +9,6 @@ name = "nac3artiq"
 crate-type = ["cdylib"]
 
 [dependencies]
-indexmap = "2.7"
 itertools = "0.14"
 pyo3 = { version = "0.21", features = ["extension-module", "gil-refs"] }
 parking_lot = "0.12"

nac3artiq/demo/min_artiq.py

@@ -16,7 +16,7 @@ __all__ = [
     "rpc", "ms", "us", "ns",
     "print_int32", "print_int64",
     "Core", "TTLOut",
-    "parallel", "legacy_parallel", "sequential"
+    "parallel", "sequential"
 ]
 
 
@@ -245,7 +245,7 @@ class Core:
         embedding = EmbeddingMap()
 
         if allow_registration:
-            compiler.analyze(registered_functions, registered_classes, special_ids, set())
+            compiler.analyze(registered_functions, registered_classes, set())
             allow_registration = False
 
         if hasattr(method, "__self__"):
@@ -336,11 +336,4 @@ class UnwrapNoneError(Exception):
     artiq_builtin = True
 
 parallel = KernelContextManager()
-legacy_parallel = KernelContextManager()
 sequential = KernelContextManager()
-
-special_ids = {
-    "parallel": id(parallel),
-    "legacy_parallel": id(legacy_parallel),
-    "sequential": id(sequential),
-}

nac3artiq/src/codegen.rs

@@ -12,10 +12,10 @@ use pyo3::{
     PyObject, PyResult, Python,
 };
 
-use super::{symbol_resolver::InnerResolver, timeline::TimeFns, SpecialPythonId};
+use super::{symbol_resolver::InnerResolver, timeline::TimeFns};
 use nac3core::{
     codegen::{
-        expr::{create_fn_and_call, destructure_range, gen_call, infer_and_call_function},
+        expr::{destructure_range, gen_call},
         llvm_intrinsics::{call_int_smax, call_memcpy, call_stackrestore, call_stacksave},
         stmt::{gen_block, gen_for_callback_incrementing, gen_if_callback, gen_with},
         type_aligned_alloca,
@@ -41,10 +41,7 @@ use nac3core::{
         numpy::unpack_ndarray_var_tys,
         DefinitionId, GenCall,
     },
-    typecheck::{
-        type_inferencer::PrimitiveStore,
-        typedef::{iter_type_vars, FunSignature, FuncArg, Type, TypeEnum, VarMap},
-    },
+    typecheck::typedef::{iter_type_vars, FunSignature, FuncArg, Type, TypeEnum, VarMap},
 };
 
 /// The parallelism mode within a block.
@@ -86,9 +83,6 @@ pub struct ArtiqCodeGenerator<'a> {
     /// The current parallel context refers to the nearest `with parallel` or `with legacy_parallel`
     /// statement, which is used to determine when and how the timeline should be updated.
     parallel_mode: ParallelMode,
-
-    /// Specially treated python IDs to identify `with parallel` and `with sequential` blocks.
-    special_ids: SpecialPythonId,
 }
 
 impl<'a> ArtiqCodeGenerator<'a> {
@@ -96,7 +90,6 @@ impl<'a> ArtiqCodeGenerator<'a> {
         name: String,
         size_t: IntType<'_>,
         timeline: &'a (dyn TimeFns + Sync),
-        special_ids: SpecialPythonId,
     ) -> ArtiqCodeGenerator<'a> {
         assert!(matches!(size_t.get_bit_width(), 32 | 64));
         ArtiqCodeGenerator {
@@ -107,7 +100,6 @@ impl<'a> ArtiqCodeGenerator<'a> {
             end: None,
             timeline,
             parallel_mode: ParallelMode::None,
-            special_ids,
         }
     }
 
@@ -117,10 +109,9 @@ impl<'a> ArtiqCodeGenerator<'a> {
         ctx: &Context,
         target_machine: &TargetMachine,
         timeline: &'a (dyn TimeFns + Sync),
-        special_ids: SpecialPythonId,
     ) -> ArtiqCodeGenerator<'a> {
         let llvm_usize = ctx.ptr_sized_int_type(&target_machine.get_target_data(), None);
-        Self::new(name, llvm_usize, timeline, special_ids)
+        Self::new(name, llvm_usize, timeline)
     }
 
     /// If the generator is currently in a direct-`parallel` block context, emits IR that resets the
@@ -266,140 +257,122 @@ impl CodeGenerator for ArtiqCodeGenerator<'_> {
             // - If there is a end variable, it indicates that we are (indirectly) inside a
             // parallel block, and we should update the max end value.
             if let ExprKind::Name { id, ctx: name_ctx } = &item.context_expr.node {
-                let resolver = ctx.resolver.clone();
-                if let Some(static_value) =
-                    if let Some((_ptr, static_value, _counter)) = ctx.var_assignment.get(id) {
-                        static_value.clone()
-                    } else if let Some(ValueEnum::Static(val)) =
-                        resolver.get_symbol_value(*id, ctx, self)
-                    {
-                        Some(val)
-                    } else {
-                        None
-                    }
-                {
-                    let python_id = static_value.get_unique_identifier();
-                    if python_id == self.special_ids.parallel
-                        || python_id == self.special_ids.legacy_parallel
-                    {
-                        let old_start = self.start.take();
-                        let old_end = self.end.take();
-                        let old_parallel_mode = self.parallel_mode;
+                if id == &"parallel".into() || id == &"legacy_parallel".into() {
+                    let old_start = self.start.take();
+                    let old_end = self.end.take();
+                    let old_parallel_mode = self.parallel_mode;
 
-                        let now = if let Some(old_start) = &old_start {
-                            self.gen_expr(ctx, old_start)?.unwrap().to_basic_value_enum(
-                                ctx,
-                                self,
-                                old_start.custom.unwrap(),
-                            )?
-                        } else {
-                            self.timeline.emit_now_mu(ctx)
-                        };
-
-                        // Emulate variable allocation, as we need to use the CodeGenContext
-                        // HashMap to store our variable due to lifetime limitation
-                        // Note: we should be able to store variables directly if generic
-                        // associative type is used by limiting the lifetime of CodeGenerator to
-                        // the LLVM Context.
-                        // The name is guaranteed to be unique as users cannot use this as variable
-                        // name.
-                        self.start = old_start.clone().map_or_else(
-                            || {
-                                let start = format!("with-{}-start", self.name_counter).into();
-                                let start_expr = Located {
-                                    // location does not matter at this point
-                                    location: stmt.location,
-                                    node: ExprKind::Name { id: start, ctx: *name_ctx },
-                                    custom: Some(ctx.primitives.int64),
-                                };
-                                let start = self
-                                    .gen_store_target(ctx, &start_expr, Some("start.addr"))?
-                                    .unwrap();
-                                ctx.builder.build_store(start, now).unwrap();
-                                Ok(Some(start_expr)) as Result<_, String>
-                            },
-                            |v| Ok(Some(v)),
-                        )?;
-                        let end = format!("with-{}-end", self.name_counter).into();
-                        let end_expr = Located {
-                            // location does not matter at this point
-                            location: stmt.location,
-                            node: ExprKind::Name { id: end, ctx: *name_ctx },
-                            custom: Some(ctx.primitives.int64),
-                        };
-                        let end = self.gen_store_target(ctx, &end_expr, Some("end.addr"))?.unwrap();
-                        ctx.builder.build_store(end, now).unwrap();
-                        self.end = Some(end_expr);
-                        self.name_counter += 1;
-                        self.parallel_mode = if python_id == self.special_ids.parallel {
-                            ParallelMode::Deep
-                        } else if python_id == self.special_ids.legacy_parallel {
-                            ParallelMode::Legacy
-                        } else {
-                            unreachable!()
-                        };
-
-                        self.gen_block(ctx, body.iter())?;
-
-                        let current = ctx.builder.get_insert_block().unwrap();
-
-                        // if the current block is terminated, move before the terminator
-                        // we want to set the timeline before reaching the terminator
-                        // TODO: This may be unsound if there are multiple exit paths in the
-                        // block... e.g.
-                        // if ...:
-                        //     return
-                        // Perhaps we can fix this by using actual with block?
-                        let reset_position = if let Some(terminator) = current.get_terminator() {
-                            ctx.builder.position_before(&terminator);
-                            true
-                        } else {
-                            false
-                        };
-
-                        // set duration
-                        let end_expr = self.end.take().unwrap();
-                        let end_val = self.gen_expr(ctx, &end_expr)?.unwrap().to_basic_value_enum(
+                    let now = if let Some(old_start) = &old_start {
+                        self.gen_expr(ctx, old_start)?.unwrap().to_basic_value_enum(
                             ctx,
                             self,
-                            end_expr.custom.unwrap(),
-                        )?;
+                            old_start.custom.unwrap(),
+                        )?
+                    } else {
+                        self.timeline.emit_now_mu(ctx)
+                    };
 
-                        // inside a sequential block
-                        if old_start.is_none() {
-                            self.timeline.emit_at_mu(ctx, end_val);
-                        }
+                    // Emulate variable allocation, as we need to use the CodeGenContext
+                    // HashMap to store our variable due to lifetime limitation
+                    // Note: we should be able to store variables directly if generic
+                    // associative type is used by limiting the lifetime of CodeGenerator to
+                    // the LLVM Context.
+                    // The name is guaranteed to be unique as users cannot use this as variable
+                    // name.
+                    self.start = old_start.clone().map_or_else(
+                        || {
+                            let start = format!("with-{}-start", self.name_counter).into();
+                            let start_expr = Located {
+                                // location does not matter at this point
+                                location: stmt.location,
+                                node: ExprKind::Name { id: start, ctx: *name_ctx },
+                                custom: Some(ctx.primitives.int64),
+                            };
+                            let start = self
+                                .gen_store_target(ctx, &start_expr, Some("start.addr"))?
+                                .unwrap();
+                            ctx.builder.build_store(start, now).unwrap();
+                            Ok(Some(start_expr)) as Result<_, String>
+                        },
+                        |v| Ok(Some(v)),
+                    )?;
+                    let end = format!("with-{}-end", self.name_counter).into();
+                    let end_expr = Located {
+                        // location does not matter at this point
+                        location: stmt.location,
+                        node: ExprKind::Name { id: end, ctx: *name_ctx },
+                        custom: Some(ctx.primitives.int64),
+                    };
+                    let end = self.gen_store_target(ctx, &end_expr, Some("end.addr"))?.unwrap();
+                    ctx.builder.build_store(end, now).unwrap();
+                    self.end = Some(end_expr);
+                    self.name_counter += 1;
+                    self.parallel_mode = match id.to_string().as_str() {
+                        "parallel" => ParallelMode::Deep,
+                        "legacy_parallel" => ParallelMode::Legacy,
+                        _ => unreachable!(),
+                    };
 
-                        // inside a parallel block, should update the outer max now_mu
-                        self.timeline_update_end_max(ctx, old_end.clone(), Some("outer.end"))?;
+                    self.gen_block(ctx, body.iter())?;
 
-                        self.parallel_mode = old_parallel_mode;
-                        self.end = old_end;
-                        self.start = old_start;
+                    let current = ctx.builder.get_insert_block().unwrap();
 
-                        if reset_position {
-                            ctx.builder.position_at_end(current);
-                        }
+                    // if the current block is terminated, move before the terminator
+                    // we want to set the timeline before reaching the terminator
+                    // TODO: This may be unsound if there are multiple exit paths in the
+                    // block... e.g.
+                    // if ...:
+                    //     return
+                    // Perhaps we can fix this by using actual with block?
+                    let reset_position = if let Some(terminator) = current.get_terminator() {
+                        ctx.builder.position_before(&terminator);
+                        true
+                    } else {
+                        false
+                    };
 
-                        return Ok(());
-                    } else if python_id == self.special_ids.sequential {
-                        // For deep parallel, temporarily take away start to avoid function calls in
-                        // the block from resetting the timeline.
-                        // This does not affect legacy parallel, as the timeline will be reset after
-                        // this block finishes execution.
-                        let start = self.start.take();
-                        self.gen_block(ctx, body.iter())?;
-                        self.start = start;
+                    // set duration
+                    let end_expr = self.end.take().unwrap();
+                    let end_val = self.gen_expr(ctx, &end_expr)?.unwrap().to_basic_value_enum(
+                        ctx,
+                        self,
+                        end_expr.custom.unwrap(),
+                    )?;
 
-                        // Reset the timeline when we are exiting the sequential block
-                        // Legacy parallel does not need this, since it will be reset after codegen
-                        // for this statement is completed
-                        if self.parallel_mode == ParallelMode::Deep {
-                            self.timeline_reset_start(ctx)?;
-                        }
-
-                        return Ok(());
+                    // inside a sequential block
+                    if old_start.is_none() {
+                        self.timeline.emit_at_mu(ctx, end_val);
                     }
+
+                    // inside a parallel block, should update the outer max now_mu
+                    self.timeline_update_end_max(ctx, old_end.clone(), Some("outer.end"))?;
+
+                    self.parallel_mode = old_parallel_mode;
+                    self.end = old_end;
+                    self.start = old_start;
+
+                    if reset_position {
+                        ctx.builder.position_at_end(current);
+                    }
+
+                    return Ok(());
+                } else if id == &"sequential".into() {
+                    // For deep parallel, temporarily take away start to avoid function calls in
+                    // the block from resetting the timeline.
+                    // This does not affect legacy parallel, as the timeline will be reset after
+                    // this block finishes execution.
+                    let start = self.start.take();
+                    self.gen_block(ctx, body.iter())?;
+                    self.start = start;
+
+                    // Reset the timeline when we are exiting the sequential block
+                    // Legacy parallel does not need this, since it will be reset after codegen
+                    // for this statement is completed
+                    if self.parallel_mode == ParallelMode::Deep {
+                        self.timeline_reset_start(ctx)?;
+                    }
+
+                    return Ok(());
                 }
             }
         }
@@ -416,7 +389,12 @@ fn gen_rpc_tag(
 ) -> Result<(), String> {
     use nac3core::typecheck::typedef::TypeEnum::*;
 
-    let PrimitiveStore { int32, int64, float, bool, str, none, .. } = ctx.primitives;
+    let int32 = ctx.primitives.int32;
+    let int64 = ctx.primitives.int64;
+    let float = ctx.primitives.float;
+    let bool = ctx.primitives.bool;
+    let str = ctx.primitives.str;
+    let none = ctx.primitives.none;
 
     if ctx.unifier.unioned(ty, int32) {
         buffer.push(b'i');
@@ -936,14 +914,47 @@ fn rpc_codegen_callback_fn<'ctx>(
     }
 
     // call
-    infer_and_call_function(
-        ctx,
-        if is_async { "rpc_send_async" } else { "rpc_send" },
-        None,
-        &[service_id.into(), tag_ptr.into(), args_ptr.into()],
-        Some("rpc.send"),
-        None,
-    );
+    if is_async {
+        let rpc_send_async = ctx.module.get_function("rpc_send_async").unwrap_or_else(|| {
+            ctx.module.add_function(
+                "rpc_send_async",
+                ctx.ctx.void_type().fn_type(
+                    &[
+                        int32.into(),
+                        tag_ptr_type.ptr_type(AddressSpace::default()).into(),
+                        ptr_type.ptr_type(AddressSpace::default()).into(),
+                    ],
+                    false,
+                ),
+                None,
+            )
+        });
+        ctx.builder
+            .build_call(
+                rpc_send_async,
+                &[service_id.into(), tag_ptr.into(), args_ptr.into()],
+                "rpc.send",
+            )
+            .unwrap();
+    } else {
+        let rpc_send = ctx.module.get_function("rpc_send").unwrap_or_else(|| {
+            ctx.module.add_function(
+                "rpc_send",
+                ctx.ctx.void_type().fn_type(
+                    &[
+                        int32.into(),
+                        tag_ptr_type.ptr_type(AddressSpace::default()).into(),
+                        ptr_type.ptr_type(AddressSpace::default()).into(),
+                    ],
+                    false,
+                ),
+                None,
+            )
+        });
+        ctx.builder
+            .build_call(rpc_send, &[service_id.into(), tag_ptr.into(), args_ptr.into()], "rpc.send")
+            .unwrap();
+    }
 
     // reclaim stack space used by arguments
     call_stackrestore(ctx, stackptr);
@@ -1157,22 +1168,29 @@ fn polymorphic_print<'ctx>(
         debug_assert!(!fmt.is_empty());
         debug_assert_eq!(fmt.as_bytes().last().unwrap(), &0u8);
 
-        let llvm_i32 = ctx.ctx.i32_type();
-        let llvm_pi8 = ctx.ctx.i8_type().ptr_type(AddressSpace::default());
+        let fn_name = if as_rtio { "rtio_log" } else { "core_log" };
+        let print_fn = ctx.module.get_function(fn_name).unwrap_or_else(|| {
+            let llvm_pi8 = ctx.ctx.i8_type().ptr_type(AddressSpace::default());
+            let fn_t = if as_rtio {
+                let llvm_void = ctx.ctx.void_type();
+                llvm_void.fn_type(&[llvm_pi8.into()], true)
+            } else {
+                let llvm_i32 = ctx.ctx.i32_type();
+                llvm_i32.fn_type(&[llvm_pi8.into()], true)
+            };
+            ctx.module.add_function(fn_name, fn_t, None)
+        });
 
         let fmt = ctx.gen_string(generator, fmt);
         let fmt = unsafe { fmt.get_field_at_index_unchecked(0) }.into_pointer_value();
 
-        create_fn_and_call(
-            ctx,
-            if as_rtio { "rtio_log" } else { "core_log" },
-            if as_rtio { None } else { Some(llvm_i32.into()) },
-            &[llvm_pi8.into()],
-            &once(fmt.into()).chain(args).map(BasicValueEnum::into).collect_vec(),
-            true,
-            None,
-            None,
-        );
+        ctx.builder
+            .build_call(
+                print_fn,
+                &once(fmt.into()).chain(args).map(BasicValueEnum::into).collect_vec(),
+                "",
+            )
+            .unwrap();
     };
 
     let llvm_i32 = ctx.ctx.i32_type();

nac3artiq/src/lib.rs

@@ -19,7 +19,6 @@ use std::{
     sync::Arc,
 };
 
-use indexmap::IndexMap;
 use itertools::Itertools;
 use parking_lot::{Mutex, RwLock};
 use pyo3::{
@@ -31,8 +30,9 @@ use tempfile::{self, TempDir};
 
 use nac3core::{
     codegen::{
-        concrete_type::ConcreteTypeStore, gen_func_impl, irrt::load_irrt, CodeGenLLVMOptions,
-        CodeGenTargetMachineOptions, CodeGenTask, CodeGenerator, WithCall, WorkerRegistry,
+        concrete_type::ConcreteTypeStore, gen_func_impl, irrt::load_irrt,
+        tracert::TraceRuntimeConfig, CodeGenLLVMOptions, CodeGenTargetMachineOptions, CodeGenTask,
+        CodeGenerator, WithCall, WorkerRegistry,
     },
     inkwell::{
         context::Context,
@@ -163,13 +163,6 @@ pub struct PrimitivePythonId {
     module: u64,
 }
 
-#[derive(Clone, Default)]
-pub struct SpecialPythonId {
-    parallel: u64,
-    legacy_parallel: u64,
-    sequential: u64,
-}
-
 type TopLevelComponent = (Stmt, String, PyObject);
 
 // TopLevelComposer is unsendable as it holds the unification table, which is
@@ -187,7 +180,6 @@ struct Nac3 {
     string_store: Arc<RwLock<HashMap<String, i32>>>,
     exception_ids: Arc<RwLock<HashMap<usize, usize>>>,
     deferred_eval_store: DeferredEvaluationStore,
-    special_ids: SpecialPythonId,
     /// LLVM-related options for code generation.
     llvm_options: CodeGenLLVMOptions,
 }
@@ -806,7 +798,6 @@ impl Nac3 {
                     &context,
                     &self.get_llvm_target_machine(),
                     self.time_fns,
-                    self.special_ids.clone(),
                 ))
             })
             .collect();
@@ -814,8 +805,13 @@ impl Nac3 {
         let membuffer = membuffers.clone();
         let mut has_return = false;
         py.allow_threads(|| {
-            let (registry, handles) =
-                WorkerRegistry::create_workers(threads, top_level.clone(), &self.llvm_options, &f);
+            let (registry, handles) = WorkerRegistry::create_workers(
+                threads,
+                top_level.clone(),
+                &self.llvm_options,
+                &TraceRuntimeConfig::default(),
+                &f,
+            );
 
             let context = Context::create();
             let mut generator = ArtiqCodeGenerator::with_target_machine(
@@ -823,7 +819,6 @@ impl Nac3 {
                 &context,
                 &self.get_llvm_target_machine(),
                 self.time_fns,
-                self.special_ids.clone(),
             );
             let module = context.create_module("main");
             let target_machine = self.llvm_options.create_target_machine().unwrap();
@@ -1203,7 +1198,6 @@ impl Nac3 {
             string_store: Arc::new(string_store.into()),
             exception_ids: Arc::default(),
             deferred_eval_store: DeferredEvaluationStore::new(),
-            special_ids: SpecialPythonId::default(),
             llvm_options: CodeGenLLVMOptions {
                 opt_level: OptimizationLevel::Default,
                 target: isa.get_llvm_target_options(),
@@ -1215,12 +1209,11 @@ impl Nac3 {
         &mut self,
         functions: &PySet,
         classes: &PySet,
-        special_ids: &PyDict,
         content_modules: &PySet,
     ) -> PyResult<()> {
         let (modules, class_ids) =
-            Python::with_gil(|py| -> PyResult<(IndexMap<u64, PyObject>, HashSet<u64>)> {
-                let mut modules: IndexMap<u64, PyObject> = IndexMap::new();
+            Python::with_gil(|py| -> PyResult<(HashMap<u64, PyObject>, HashSet<u64>)> {
+                let mut modules: HashMap<u64, PyObject> = HashMap::new();
                 let mut class_ids: HashSet<u64> = HashSet::new();
 
                 let id_fn = PyModule::import(py, "builtins")?.getattr("id")?;
@@ -1249,25 +1242,6 @@ impl Nac3 {
         for module in modules.into_values() {
             self.register_module(&module, &class_ids)?;
         }
-
-        self.special_ids = SpecialPythonId {
-            parallel: special_ids.get_item("parallel").ok().flatten().unwrap().extract().unwrap(),
-            legacy_parallel: special_ids
-                .get_item("legacy_parallel")
-                .ok()
-                .flatten()
-                .unwrap()
-                .extract()
-                .unwrap(),
-            sequential: special_ids
-                .get_item("sequential")
-                .ok()
-                .flatten()
-                .unwrap()
-                .extract()
-                .unwrap(),
-        };
-
         Ok(())
     }
 

nac3artiq/src/timeline.rs

@@ -1,6 +1,11 @@
+use itertools::Either;
+
 use nac3core::{
-    codegen::{expr::infer_and_call_function, CodeGenContext},
-    inkwell::{values::BasicValueEnum, AddressSpace, AtomicOrdering},
+    codegen::CodeGenContext,
+    inkwell::{
+        values::{BasicValueEnum, CallSiteValue},
+        AddressSpace, AtomicOrdering,
+    },
 };
 
 /// Functions for manipulating the timeline.
@@ -283,27 +288,36 @@ pub struct ExternTimeFns {}
 
 impl TimeFns for ExternTimeFns {
     fn emit_now_mu<'ctx>(&self, ctx: &mut CodeGenContext<'ctx, '_>) -> BasicValueEnum<'ctx> {
-        infer_and_call_function(
-            ctx,
-            "now_mu",
-            Some(ctx.ctx.i64_type().into()),
-            &[],
-            Some("now_mu"),
-            None,
-        )
-        .unwrap()
+        let now_mu = ctx.module.get_function("now_mu").unwrap_or_else(|| {
+            ctx.module.add_function("now_mu", ctx.ctx.i64_type().fn_type(&[], false), None)
+        });
+        ctx.builder
+            .build_call(now_mu, &[], "now_mu")
+            .map(CallSiteValue::try_as_basic_value)
+            .map(Either::unwrap_left)
+            .unwrap()
     }
 
     fn emit_at_mu<'ctx>(&self, ctx: &mut CodeGenContext<'ctx, '_>, t: BasicValueEnum<'ctx>) {
-        assert_eq!(t.get_type(), ctx.ctx.i64_type().into());
-
-        infer_and_call_function(ctx, "at_mu", None, &[t], Some("at_mu"), None);
+        let at_mu = ctx.module.get_function("at_mu").unwrap_or_else(|| {
+            ctx.module.add_function(
+                "at_mu",
+                ctx.ctx.void_type().fn_type(&[ctx.ctx.i64_type().into()], false),
+                None,
+            )
+        });
+        ctx.builder.build_call(at_mu, &[t.into()], "at_mu").unwrap();
     }
 
     fn emit_delay_mu<'ctx>(&self, ctx: &mut CodeGenContext<'ctx, '_>, dt: BasicValueEnum<'ctx>) {
-        assert_eq!(dt.get_type(), ctx.ctx.i64_type().into());
-
-        infer_and_call_function(ctx, "delay_mu", None, &[dt], Some("delay_mu"), None);
+        let delay_mu = ctx.module.get_function("delay_mu").unwrap_or_else(|| {
+            ctx.module.add_function(
+                "delay_mu",
+                ctx.ctx.void_type().fn_type(&[ctx.ctx.i64_type().into()], false),
+                None,
+            )
+        });
+        ctx.builder.build_call(delay_mu, &[dt.into()], "delay_mu").unwrap();
     }
 }
 

nac3core/Cargo.toml

@@ -8,6 +8,7 @@ edition = "2021"
 default = ["derive"]
 derive = ["dep:nac3core_derive"]
 no-escape-analysis = []
+tracing = []
 
 [dependencies]
 itertools = "0.14"
@@ -30,4 +31,5 @@ indoc = "2.0"
 insta = "=1.11.0"
 
 [build-dependencies]
+itertools = "0.14"
 regex = "1.11"

nac3core/build.rs

@@ -1,3 +1,4 @@
+use std::ffi::OsStr;
 use std::{
     env,
     fs::File,
@@ -6,14 +7,28 @@ use std::{
     process::{Command, Stdio},
 };
 
+use itertools::Itertools;
 use regex::Regex;
 
-fn main() {
+struct IRRTCompilation<'a> {
+    pub file: &'a str,
+    pub gcc_options: Vec<&'a str>,
+    pub cargo_instructions: Vec<&'a str>,
+}
+
+/// Extracts the extension-less filename from a [`Path`].
+fn path_to_extless_filename(path: &Path) -> &str {
+    path.file_name().map(Path::new).and_then(Path::file_stem).and_then(OsStr::to_str).unwrap()
+}
+
+/// Compiles a source C file into LLVM bitcode.
+fn compile_file_to_ir(compile_opts: &IRRTCompilation) {
     let out_dir = env::var("OUT_DIR").unwrap();
-    let out_dir = Path::new(&out_dir);
+    let out_path = Path::new(&out_dir);
     let irrt_dir = Path::new("irrt");
 
-    let irrt_cpp_path = irrt_dir.join("irrt.cpp");
+    let path = Path::new(compile_opts.file);
+    let filename_without_ext = path_to_extless_filename(path);
 
     /*
      * HACK: Sadly, clang doesn't let us emit generic LLVM bitcode.
@@ -35,22 +50,22 @@ fn main() {
         "-",
         "-I",
         irrt_dir.to_str().unwrap(),
-        irrt_cpp_path.to_str().unwrap(),
     ];
 
+    // Apply custom flags from IRRTCompilation
+    flags.extend_from_slice(&compile_opts.gcc_options);
+
     match env::var("PROFILE").as_deref() {
-        Ok("debug") => {
-            flags.push("-O0");
-            flags.push("-DIRRT_DEBUG_ASSERT");
-        }
-        Ok("release") => {
-            flags.push("-O3");
-        }
+        Ok("debug") => flags.extend_from_slice(&["-O0", "-DIRRT_DEBUG_ASSERT"]),
+        Ok("release") => flags.push("-O3"),
         flavor => panic!("Unknown or missing build flavor {flavor:?}"),
     }
 
-    // Tell Cargo to rerun if any file under `irrt_dir` (recursive) changes
-    println!("cargo:rerun-if-changed={}", irrt_dir.to_str().unwrap());
+    flags.push(path.to_str().unwrap());
+
+    // Tell Cargo to rerun if the main IRRT source is changed
+    println!("cargo:rerun-if-changed={}", path.to_str().unwrap());
+    compile_opts.cargo_instructions.iter().for_each(|inst| println!("cargo::{inst}"));
 
     // Compile IRRT and capture the LLVM IR output
     let output = Command::new("clang-irrt")
@@ -61,8 +76,7 @@ fn main() {
         })
         .unwrap();
 
-    // https://github.com/rust-lang/regex/issues/244
-    let output = std::str::from_utf8(&output.stdout).unwrap().replace("\r\n", "\n");
+    let output = std::str::from_utf8(&output.stdout).unwrap();
     let mut filtered_output = String::with_capacity(output.len());
 
     // Filter out irrelevant IR
@@ -76,7 +90,7 @@ fn main() {
         r"(?ms:^define.*?\}$)|(?m:^declare.*?$)|(?m:^%.+?=\s*type\s*\{.+?\}$)|(?m:^@.+?=.+$)",
     )
     .unwrap();
-    for f in regex_filter.captures_iter(&output) {
+    for f in regex_filter.captures_iter(output) {
         assert_eq!(f.len(), 1);
         filtered_output.push_str(&f[0]);
         filtered_output.push('\n');
@@ -90,20 +104,47 @@ fn main() {
     // Doing `DEBUG_DUMP_IRRT=1 cargo build -p nac3core` dumps the LLVM IR generated
     const DEBUG_DUMP_IRRT: &str = "DEBUG_DUMP_IRRT";
     println!("cargo:rerun-if-env-changed={DEBUG_DUMP_IRRT}");
-    if env::var(DEBUG_DUMP_IRRT).is_ok() {
-        let mut file = File::create(out_dir.join("irrt.ll")).unwrap();
+    if env::var("DEBUG_DUMP_IRRT").is_ok() {
+        let mut file = File::create(out_path.join(format!("{filename_without_ext}.ll"))).unwrap();
         file.write_all(output.as_bytes()).unwrap();
 
-        let mut file = File::create(out_dir.join("irrt-filtered.ll")).unwrap();
+        let mut file =
+            File::create(out_path.join(format!("{filename_without_ext}-filtered.ll"))).unwrap();
         file.write_all(filtered_output.as_bytes()).unwrap();
     }
 
     let mut llvm_as = Command::new("llvm-as-irrt")
         .stdin(Stdio::piped())
         .arg("-o")
-        .arg(out_dir.join("irrt.bc"))
+        .arg(out_path.join(format!("{filename_without_ext}.bc")))
         .spawn()
         .unwrap();
     llvm_as.stdin.as_mut().unwrap().write_all(filtered_output.as_bytes()).unwrap();
     assert!(llvm_as.wait().unwrap().success());
 }
+
+fn main() {
+    let irrt_compilations: &[IRRTCompilation] = &[
+        IRRTCompilation {
+            file: "irrt/irrt.cpp",
+            gcc_options: Vec::default(),
+            cargo_instructions: vec!["rerun-if-changed=irrt/irrt"],
+        },
+        IRRTCompilation {
+            file: "irrt/tracert.cpp",
+            gcc_options: Vec::default(),
+            cargo_instructions: Vec::default(),
+        },
+    ];
+
+    assert!(irrt_compilations
+        .iter()
+        .map(|comp| comp.file)
+        .map(Path::new)
+        .map(path_to_extless_filename)
+        .all_unique());
+
+    for path in irrt_compilations {
+        compile_file_to_ir(path)
+    }
+}

nac3core/irrt/tracert.cpp

@@ -0,0 +1,4 @@
+extern "C" {
+// stdio.h
+int printf(const char *format, ...);
+}  // extern "C"

nac3core/src/codegen/expr.rs

@@ -32,9 +32,7 @@ use super::{
         gen_for_callback_incrementing, gen_if_callback, gen_if_else_expr_callback, gen_raise,
         gen_var,
     },
-    types::{
-        ndarray::NDArrayType, ExceptionType, ListType, OptionType, RangeType, StringType, TupleType,
-    },
+    types::{ndarray::NDArrayType, ListType, RangeType},
     values::{
         ndarray::{NDArrayOut, RustNDIndex, ScalarOrNDArray},
         ArrayLikeIndexer, ArrayLikeValue, ListValue, ProxyValue, RangeValue,
@@ -45,7 +43,7 @@ use super::{
 use crate::{
     symbol_resolver::{SymbolValue, ValueEnum},
     toplevel::{
-        helper::{arraylike_flatten_element_type, extract_ndims, PrimDef},
+        helper::{arraylike_flatten_element_type, PrimDef},
         numpy::unpack_ndarray_var_tys,
         DefinitionId, TopLevelDef,
     },
@@ -170,27 +168,65 @@ impl<'ctx> CodeGenContext<'ctx, '_> {
             SymbolValue::Bool(v) => self.ctx.i8_type().const_int(u64::from(*v), true).into(),
             SymbolValue::Double(v) => self.ctx.f64_type().const_float(*v).into(),
             SymbolValue::Str(v) => {
-                StringType::new(self).construct_constant(self, v, None).as_abi_value(self).into()
+                let str_ptr = self
+                    .builder
+                    .build_global_string_ptr(v, "const")
+                    .map(|v| v.as_pointer_value().into())
+                    .unwrap();
+                let size = self.get_size_type().const_int(v.len() as u64, false);
+                let ty = self.get_llvm_type(generator, self.primitives.str).into_struct_type();
+                ty.const_named_struct(&[str_ptr, size.into()]).into()
             }
             SymbolValue::Tuple(ls) => {
                 let vals = ls.iter().map(|v| self.gen_symbol_val(generator, v, ty)).collect_vec();
                 let fields = vals.iter().map(BasicValueEnum::get_type).collect_vec();
-                TupleType::new(self, &fields)
-                    .construct_from_objects(self, vals, Some("tup_val"))
-                    .as_abi_value(self)
-                    .into()
+                let ty = self.ctx.struct_type(&fields, false);
+                let ptr = gen_var(self, ty.into(), Some("tuple")).unwrap();
+                let zero = self.ctx.i32_type().const_zero();
+                unsafe {
+                    for (i, val) in vals.into_iter().enumerate() {
+                        let p = self
+                            .builder
+                            .build_in_bounds_gep(
+                                ptr,
+                                &[zero, self.ctx.i32_type().const_int(i as u64, false)],
+                                "elemptr",
+                            )
+                            .unwrap();
+                        self.builder.build_store(p, val).unwrap();
+                    }
+                }
+                self.builder.build_load(ptr, "tup_val").unwrap()
             }
             SymbolValue::OptionSome(v) => {
+                let ty = match self.unifier.get_ty_immutable(ty).as_ref() {
+                    TypeEnum::TObj { obj_id, params, .. }
+                        if *obj_id == self.primitives.option.obj_id(&self.unifier).unwrap() =>
+                    {
+                        *params.iter().next().unwrap().1
+                    }
+                    _ => codegen_unreachable!(self, "must be option type"),
+                };
                 let val = self.gen_symbol_val(generator, v, ty);
-                OptionType::from_unifier_type(generator, self, ty)
-                    .construct_some_value(generator, self, &val, None)
-                    .as_abi_value(self)
-                    .into()
+                let ptr = generator
+                    .gen_var_alloc(self, val.get_type(), Some("default_opt_some"))
+                    .unwrap();
+                self.builder.build_store(ptr, val).unwrap();
+                ptr.into()
+            }
+            SymbolValue::OptionNone => {
+                let ty = match self.unifier.get_ty_immutable(ty).as_ref() {
+                    TypeEnum::TObj { obj_id, params, .. }
+                        if *obj_id == self.primitives.option.obj_id(&self.unifier).unwrap() =>
+                    {
+                        *params.iter().next().unwrap().1
+                    }
+                    _ => codegen_unreachable!(self, "must be option type"),
+                };
+                let actual_ptr_type =
+                    self.get_llvm_type(generator, ty).ptr_type(AddressSpace::default());
+                actual_ptr_type.const_null().into()
             }
-            SymbolValue::OptionNone => OptionType::from_unifier_type(generator, self, ty)
-                .construct_empty(generator, self, None)
-                .as_abi_value(self)
-                .into(),
         }
     }
 
@@ -285,10 +321,15 @@ impl<'ctx> CodeGenContext<'ctx, '_> {
                 if let Some(v) = self.const_strings.get(v) {
                     Some(*v)
                 } else {
-                    let val = StringType::new(self)
-                        .construct_constant(self, v, None)
-                        .as_abi_value(self)
-                        .into();
+                    let str_ptr = self
+                        .builder
+                        .build_global_string_ptr(v, "const")
+                        .map(|v| v.as_pointer_value().into())
+                        .unwrap();
+                    let size = self.get_size_type().const_int(v.len() as u64, false);
+                    let ty = self.get_llvm_type(generator, self.primitives.str);
+                    let val =
+                        ty.into_struct_type().const_named_struct(&[str_ptr, size.into()]).into();
                     self.const_strings.insert(v.to_string(), val);
                     Some(val)
                 }
@@ -578,35 +619,42 @@ impl<'ctx> CodeGenContext<'ctx, '_> {
         params: [Option<IntValue<'ctx>>; 3],
         loc: Location,
     ) {
-        let llvm_i32 = self.ctx.i32_type();
-        let llvm_i64 = self.ctx.i64_type();
-        let llvm_exn = ExceptionType::get_instance(generator, self);
-
         let zelf = if let Some(exception_val) = self.exception_val {
-            llvm_exn.map_pointer_value(exception_val, Some("exn"))
+            exception_val
         } else {
-            let zelf = llvm_exn.alloca_var(generator, self, Some("exn"));
-            self.exception_val = Some(zelf.as_abi_value(self));
-            zelf
+            let ty = self.get_llvm_type(generator, self.primitives.exception).into_pointer_type();
+            let zelf_ty: BasicTypeEnum = ty.get_element_type().into_struct_type().into();
+            let zelf = generator.gen_var_alloc(self, zelf_ty, Some("exn")).unwrap();
+            *self.exception_val.insert(zelf)
         };
-
-        let id = self.resolver.get_string_id(name);
-        zelf.store_name(self, llvm_i32.const_int(id as u64, false));
-        zelf.store_message(self, msg.into_struct_value());
-        zelf.store_params(
-            self,
-            params
-                .iter()
-                .map(|p| {
-                    p.map_or(llvm_i64.const_zero(), |v| {
-                        self.builder.build_int_s_extend(v, self.ctx.i64_type(), "sext").unwrap()
-                    })
-                })
-                .collect_array()
-                .as_ref()
-                .unwrap(),
-        );
-        gen_raise(generator, self, Some(&zelf), loc);
+        let int32 = self.ctx.i32_type();
+        let zero = int32.const_zero();
+        unsafe {
+            let id_ptr = self.builder.build_in_bounds_gep(zelf, &[zero, zero], "exn.id").unwrap();
+            let id = self.resolver.get_string_id(name);
+            self.builder.build_store(id_ptr, int32.const_int(id as u64, false)).unwrap();
+            let ptr = self
+                .builder
+                .build_in_bounds_gep(zelf, &[zero, int32.const_int(5, false)], "exn.msg")
+                .unwrap();
+            self.builder.build_store(ptr, msg).unwrap();
+            let i64_zero = self.ctx.i64_type().const_zero();
+            for (i, attr_ind) in [6, 7, 8].iter().enumerate() {
+                let ptr = self
+                    .builder
+                    .build_in_bounds_gep(
+                        zelf,
+                        &[zero, int32.const_int(*attr_ind, false)],
+                        "exn.param",
+                    )
+                    .unwrap();
+                let val = params[i].map_or(i64_zero, |v| {
+                    self.builder.build_int_s_extend(v, self.ctx.i64_type(), "sext").unwrap()
+                });
+                self.builder.build_store(ptr, val).unwrap();
+            }
+        }
+        gen_raise(generator, self, Some(&zelf.into()), loc);
     }
 
     pub fn make_assert<G: CodeGenerator + ?Sized>(
@@ -1271,7 +1319,7 @@ pub fn gen_binop_expr_with_values<'ctx, G: CodeGenerator>(
     op: Binop,
     right: (&Option<Type>, BasicValueEnum<'ctx>),
     loc: Location,
-) -> Result<BasicValueEnum<'ctx>, String> {
+) -> Result<Option<ValueEnum<'ctx>>, String> {
     let (left_ty, left_val) = left;
     let (right_ty, right_val) = right;
 
@@ -1282,14 +1330,14 @@ pub fn gen_binop_expr_with_values<'ctx, G: CodeGenerator>(
     // which would be unchanged until further unification, which we would never do
     // when doing code generation for function instances
     if ty1 == ty2 && [ctx.primitives.int32, ctx.primitives.int64].contains(&ty1) {
-        Ok(ctx.gen_int_ops(generator, op.base, left_val, right_val, true))
+        Ok(Some(ctx.gen_int_ops(generator, op.base, left_val, right_val, true).into()))
     } else if ty1 == ty2 && [ctx.primitives.uint32, ctx.primitives.uint64].contains(&ty1) {
-        Ok(ctx.gen_int_ops(generator, op.base, left_val, right_val, false))
+        Ok(Some(ctx.gen_int_ops(generator, op.base, left_val, right_val, false).into()))
     } else if [Operator::LShift, Operator::RShift].contains(&op.base) {
         let signed = [ctx.primitives.int32, ctx.primitives.int64].contains(&ty1);
-        Ok(ctx.gen_int_ops(generator, op.base, left_val, right_val, signed))
+        Ok(Some(ctx.gen_int_ops(generator, op.base, left_val, right_val, signed).into()))
     } else if ty1 == ty2 && ctx.primitives.float == ty1 {
-        Ok(ctx.gen_float_ops(op.base, left_val, right_val))
+        Ok(Some(ctx.gen_float_ops(op.base, left_val, right_val).into()))
     } else if ty1 == ctx.primitives.float && ty2 == ctx.primitives.int32 {
         // Pow is the only operator that would pass typecheck between float and int
         assert_eq!(op.base, Operator::Pow);
@@ -1299,7 +1347,7 @@ pub fn gen_binop_expr_with_values<'ctx, G: CodeGenerator>(
             right_val.into_int_value(),
             Some("f_pow_i"),
         );
-        Ok(res.into())
+        Ok(Some(res.into()))
     } else if ty1.obj_id(&ctx.unifier).is_some_and(|id| id == PrimDef::List.id())
         || ty2.obj_id(&ctx.unifier).is_some_and(|id| id == PrimDef::List.id())
     {
@@ -1389,7 +1437,7 @@ pub fn gen_binop_expr_with_values<'ctx, G: CodeGenerator>(
                     ctx.ctx.bool_type().const_zero(),
                 );
 
-                Ok(new_list.as_abi_value(ctx).into())
+                Ok(Some(new_list.as_abi_value(ctx).into()))
             }
 
             Operator::Mult => {
@@ -1476,7 +1524,7 @@ pub fn gen_binop_expr_with_values<'ctx, G: CodeGenerator>(
                     llvm_usize.const_int(1, false),
                 )?;
 
-                Ok(new_list.as_abi_value(ctx).into())
+                Ok(Some(new_list.as_abi_value(ctx).into()))
             }
 
             _ => todo!("Operator not supported"),
@@ -1515,7 +1563,7 @@ pub fn gen_binop_expr_with_values<'ctx, G: CodeGenerator>(
             let result = left
                 .matmul(generator, ctx, ty1, (ty2, right), (common_dtype, out))
                 .split_unsized(generator, ctx);
-            Ok(result.to_basic_value_enum())
+            Ok(Some(result.to_basic_value_enum().into()))
         } else {
             // For other operations, they are all elementwise operations.
 
@@ -1546,12 +1594,14 @@ pub fn gen_binop_expr_with_values<'ctx, G: CodeGenerator>(
                     op,
                     (&Some(ty2_dtype), right_value),
                     ctx.current_loc,
-                )?;
+                )?
+                .unwrap()
+                .to_basic_value_enum(ctx, generator, common_dtype)?;
 
                 Ok(result)
             })
             .unwrap();
-            Ok(result.as_abi_value(ctx).into())
+            Ok(Some(result.as_abi_value(ctx).into()))
         }
     } else {
         let left_ty_enum = ctx.unifier.get_ty_immutable(left_ty.unwrap());
@@ -1600,8 +1650,7 @@ pub fn gen_binop_expr_with_values<'ctx, G: CodeGenerator>(
                 (&signature, fun_id),
                 vec![(None, right_val.into())],
             )
-            .map(Option::unwrap)
-            .map(BasicValueEnum::into)
+            .map(|f| f.map(Into::into))
     }
 }
 
@@ -1639,7 +1688,6 @@ pub fn gen_binop_expr<'ctx, G: CodeGenerator>(
         (&right.custom, right_val),
         loc,
     )
-    .map(|res| Some(res.into()))
 }
 
 /// Generates LLVM IR for a unary operator expression using the [`Type`] and
@@ -1649,19 +1697,18 @@ pub fn gen_unaryop_expr_with_values<'ctx, G: CodeGenerator>(
     ctx: &mut CodeGenContext<'ctx, '_>,
     op: ast::Unaryop,
     operand: (&Option<Type>, BasicValueEnum<'ctx>),
-) -> Result<BasicValueEnum<'ctx>, String> {
+) -> Result<Option<ValueEnum<'ctx>>, String> {
     let (ty, val) = operand;
     let ty = ctx.unifier.get_representative(ty.unwrap());
 
-    Ok(if ty == ctx.primitives.bool {
+    Ok(Some(if ty == ctx.primitives.bool {
         let val = val.into_int_value();
         if op == ast::Unaryop::Not {
-            let not = ctx
-                .builder
-                .build_int_compare(IntPredicate::EQ, val, val.get_type().const_zero(), "not")
-                .unwrap();
+            let not = ctx.builder.build_not(val, "not").unwrap();
+            let not_bool =
+                ctx.builder.build_and(not, not.get_type().const_int(1, false), "").unwrap();
 
-            generator.bool_to_int_type(ctx, not, val.get_type()).into()
+            not_bool.into()
         } else {
             let llvm_i32 = ctx.ctx.i32_type();
 
@@ -1674,6 +1721,7 @@ pub fn gen_unaryop_expr_with_values<'ctx, G: CodeGenerator>(
                     ctx.builder.build_int_z_extend(val, llvm_i32, "").map(Into::into).unwrap(),
                 ),
             )?
+            .unwrap()
         }
     } else if [
         ctx.primitives.int32,
@@ -1727,13 +1775,10 @@ pub fn gen_unaryop_expr_with_values<'ctx, G: CodeGenerator>(
             if op == ast::Unaryop::Invert {
                 ast::Unaryop::Not
             } else {
-                let ndims = extract_ndims(&ctx.unifier, ty);
-
                 codegen_unreachable!(
                     ctx,
-                    "ufunc {} not supported for ndarray[bool, {}]",
+                    "ufunc {} not supported for ndarray[bool, N]",
                     op.op_info().method_name,
-                    ndims,
                 )
             }
         } else {
@@ -1745,14 +1790,16 @@ pub fn gen_unaryop_expr_with_values<'ctx, G: CodeGenerator>(
             ctx,
             NDArrayOut::NewNDArray { dtype: ndarray.get_type().element_type() },
             |generator, ctx, scalar| {
-                gen_unaryop_expr_with_values(generator, ctx, op, (&Some(ndarray_dtype), scalar))
+                gen_unaryop_expr_with_values(generator, ctx, op, (&Some(ndarray_dtype), scalar))?
+                    .map(|val| val.to_basic_value_enum(ctx, generator, ndarray_dtype))
+                    .unwrap()
             },
         )?;
 
         mapped_ndarray.as_abi_value(ctx).into()
     } else {
         unimplemented!()
-    })
+    }))
 }
 
 /// Generates LLVM IR for a unary operator expression.
@@ -1772,7 +1819,6 @@ pub fn gen_unaryop_expr<'ctx, G: CodeGenerator>(
     };
 
     gen_unaryop_expr_with_values(generator, ctx, op, (&operand.custom, val))
-        .map(|res| Some(res.into()))
 }
 
 /// Generates LLVM IR for a comparison operator expression using the [`Type`] and
@@ -1783,7 +1829,7 @@ pub fn gen_cmpop_expr_with_values<'ctx, G: CodeGenerator>(
     left: (Option<Type>, BasicValueEnum<'ctx>),
     ops: &[ast::Cmpop],
     comparators: &[(Option<Type>, BasicValueEnum<'ctx>)],
-) -> Result<BasicValueEnum<'ctx>, String> {
+) -> Result<Option<ValueEnum<'ctx>>, String> {
     debug_assert_eq!(comparators.len(), ops.len());
 
     if comparators.len() == 1 {
@@ -1825,13 +1871,19 @@ pub fn gen_cmpop_expr_with_values<'ctx, G: CodeGenerator>(
                         (Some(left_ty_dtype), left_scalar),
                         &[op],
                         &[(Some(right_ty_dtype), right_scalar)],
+                    )?
+                    .unwrap()
+                    .to_basic_value_enum(
+                        ctx,
+                        generator,
+                        ctx.primitives.bool,
                     )?;
 
                     Ok(generator.bool_to_i8(ctx, val.into_int_value()).into())
                 },
             )?;
 
-            return Ok(result_ndarray.as_abi_value(ctx).into());
+            return Ok(Some(result_ndarray.as_abi_value(ctx).into()));
         }
     }
 
@@ -1915,19 +1967,41 @@ pub fn gen_cmpop_expr_with_values<'ctx, G: CodeGenerator>(
             } else if left_ty == ctx.primitives.str {
                 assert!(ctx.unifier.unioned(left_ty, right_ty));
 
-                let llvm_str = StringType::new(ctx);
+                let lhs = lhs.into_struct_value();
+                let rhs = rhs.into_struct_value();
 
-                let lhs = llvm_str.map_struct_value(lhs.into_struct_value(), None);
-                let rhs = llvm_str.map_struct_value(rhs.into_struct_value(), None);
+                let llvm_i32 = ctx.ctx.i32_type();
+                let llvm_usize = ctx.get_size_type();
 
-                let result = call_string_eq(ctx, lhs, rhs);
+                let plhs = generator.gen_var_alloc(ctx, lhs.get_type().into(), None).unwrap();
+                ctx.builder.build_store(plhs, lhs).unwrap();
+                let prhs = generator.gen_var_alloc(ctx, lhs.get_type().into(), None).unwrap();
+                ctx.builder.build_store(prhs, rhs).unwrap();
+
+                let lhs_ptr = ctx.build_in_bounds_gep_and_load(
+                    plhs,
+                    &[llvm_usize.const_zero(), llvm_i32.const_zero()],
+                    None,
+                ).into_pointer_value();
+                let lhs_len = ctx.build_in_bounds_gep_and_load(
+                    plhs,
+                    &[llvm_usize.const_zero(), llvm_i32.const_int(1, false)],
+                    None,
+                ).into_int_value();
+
+                let rhs_ptr = ctx.build_in_bounds_gep_and_load(
+                    prhs,
+                    &[llvm_usize.const_zero(), llvm_i32.const_zero()],
+                    None,
+                ).into_pointer_value();
+                let rhs_len = ctx.build_in_bounds_gep_and_load(
+                    prhs,
+                    &[llvm_usize.const_zero(), llvm_i32.const_int(1, false)],
+                    None,
+                ).into_int_value();
+                let result = call_string_eq(ctx, lhs_ptr, lhs_len, rhs_ptr, rhs_len);
                 if *op == Cmpop::NotEq {
-                    gen_unaryop_expr_with_values(
-                        generator,
-                        ctx,
-                        Unaryop::Not,
-                        (&Some(ctx.primitives.bool), result.into()),
-                    )?.into_int_value()
+                    ctx.builder.build_not(result, "").unwrap() 
                 } else {
                     result
                 }
@@ -2030,6 +2104,9 @@ pub fn gen_cmpop_expr_with_values<'ctx, G: CodeGenerator>(
                                         &[Cmpop::Eq],
                                         &[(Some(right_elem_ty), right)],
                                     )?
+                                    .unwrap()
+                                    .to_basic_value_enum(ctx, generator, ctx.primitives.bool)
+                                    .unwrap()
                                     .into_int_value();
 
                                     gen_if_callback(
@@ -2078,6 +2155,8 @@ pub fn gen_cmpop_expr_with_values<'ctx, G: CodeGenerator>(
                                     Unaryop::Not,
                                     (&Some(ctx.primitives.bool), acc.into()),
                                 )?
+                                .unwrap()
+                                .to_basic_value_enum(ctx, generator, ctx.primitives.bool)?
                                 .into_int_value()
                             } else {
                                 acc
@@ -2165,6 +2244,11 @@ pub fn gen_cmpop_expr_with_values<'ctx, G: CodeGenerator>(
                                 &[op],
                                 &[(Some(right_ty), right_elem)],
                             )
+                                .transpose()
+                                .unwrap()
+                                .and_then(|v| {
+                                    v.to_basic_value_enum(ctx, generator, ctx.primitives.bool)
+                                })
                                 .map(BasicValueEnum::into_int_value)?;
 
                             Ok(ctx.builder.build_not(
@@ -2201,12 +2285,7 @@ pub fn gen_cmpop_expr_with_values<'ctx, G: CodeGenerator>(
 
                 // Invert the final value if __ne__
                 if *op == Cmpop::NotEq {
-                    gen_unaryop_expr_with_values(
-                        generator,
-                        ctx,
-                        Unaryop::Not,
-                        (&Some(ctx.primitives.bool), cmp_phi.into()),
-                    )?.into_int_value()
+                    ctx.builder.build_not(cmp_phi, "").unwrap()
                 } else {
                     cmp_phi
                 }
@@ -2231,9 +2310,12 @@ pub fn gen_cmpop_expr_with_values<'ctx, G: CodeGenerator>(
             };
 
             Ok(prev?.map(|v| ctx.builder.build_and(v, current, "cmp").unwrap()).or(Some(current)))
-        })?.unwrap();
+        })?;
 
-    Ok(cmp_val.into())
+    Ok(Some(match cmp_val {
+        Some(v) => v.into(),
+        None => return Ok(None),
+    }))
 }
 
 /// Generates LLVM IR for a comparison operator expression.
@@ -2280,7 +2362,6 @@ pub fn gen_cmpop_expr<'ctx, G: CodeGenerator>(
         ops,
         comparator_vals.as_slice(),
     )
-    .map(|res| Some(res.into()))
 }
 
 /// See [`CodeGenerator::gen_expr`].
@@ -2310,13 +2391,16 @@ pub fn gen_expr<'ctx, G: CodeGenerator>(
             const_val.into()
         }
         ExprKind::Name { id, .. } if id == &"none".into() => {
-            match &*ctx.unifier.get_ty(expr.custom.unwrap()) {
-                TypeEnum::TObj { obj_id, .. }
-                    if *obj_id == ctx.primitives.option.obj_id(&ctx.unifier).unwrap() =>
+            match (
+                ctx.unifier.get_ty(expr.custom.unwrap()).as_ref(),
+                ctx.unifier.get_ty(ctx.primitives.option).as_ref(),
+            ) {
+                (TypeEnum::TObj { obj_id, params, .. }, TypeEnum::TObj { obj_id: opt_id, .. })
+                    if *obj_id == *opt_id =>
                 {
-                    OptionType::from_unifier_type(generator, ctx, expr.custom.unwrap())
-                        .construct_empty(generator, ctx, None)
-                        .as_abi_value(ctx)
+                    ctx.get_llvm_type(generator, *params.iter().next().unwrap().1)
+                        .ptr_type(AddressSpace::default())
+                        .const_null()
                         .into()
                 }
                 _ => codegen_unreachable!(ctx, "must be option type"),
@@ -2801,12 +2885,8 @@ pub fn gen_expr<'ctx, G: CodeGenerator>(
                                 };
                             }
                             ValueEnum::Dynamic(BasicValueEnum::PointerValue(ptr)) => {
-                                let option = OptionType::from_pointer_type(
-                                    ptr.get_type(),
-                                    ctx.get_size_type(),
-                                )
-                                .map_pointer_value(ptr, None);
-                                let not_null = option.is_some(ctx);
+                                let not_null =
+                                    ctx.builder.build_is_not_null(ptr, "unwrap_not_null").unwrap();
                                 ctx.make_assert(
                                     generator,
                                     not_null,
@@ -2815,7 +2895,12 @@ pub fn gen_expr<'ctx, G: CodeGenerator>(
                                     [None, None, None],
                                     expr.location,
                                 );
-                                return Ok(Some(unsafe { option.load(ctx).into() }));
+                                return Ok(Some(
+                                    ctx.builder
+                                        .build_load(ptr, "unwrap_some_load")
+                                        .map(Into::into)
+                                        .unwrap(),
+                                ));
                             }
                             ValueEnum::Dynamic(_) => {
                                 codegen_unreachable!(ctx, "option must be static or ptr")

nac3core/src/codegen/extern_fns.rs

@@ -1,9 +1,13 @@
+use std::iter::once;
+
 use inkwell::{
     attributes::{Attribute, AttributeLoc},
-    values::{BasicValueEnum, FloatValue, IntValue},
+    values::{BasicValue, BasicValueEnum, CallSiteValue, FloatValue, IntValue},
+    AddressSpace,
 };
+use itertools::{Either, Itertools};
 
-use super::{expr::infer_and_call_function, CodeGenContext};
+use super::CodeGenContext;
 
 /// Macro to generate extern function
 /// Both function return type and function parameter type are `FloatValue`
@@ -19,7 +23,7 @@ use super::{expr::infer_and_call_function, CodeGenContext};
 ///   These will be used unless other attributes are specified
 /// * `$(,$args:ident)*`: Operands of the extern function
 ///   The data type of these operands will be set to `FloatValue`
-///  
+///
 macro_rules! generate_extern_fn {
     ("unary", $fn_name:ident, $extern_fn:literal) => {
         generate_extern_fn!($fn_name, $extern_fn, arg, "mustprogress", "nofree", "nounwind", "willreturn", "writeonly");
@@ -36,8 +40,8 @@ macro_rules! generate_extern_fn {
     ($fn_name:ident, $extern_fn:literal $(,$args:ident)* $(,$attributes:literal)*) => {
         #[doc = concat!("Invokes the [`", stringify!($extern_fn), "`](https://en.cppreference.com/w/c/numeric/math/", stringify!($llvm_name), ") function." )]
         pub fn $fn_name<'ctx>(
-            ctx: &CodeGenContext<'ctx, '_>,
-            $($args: FloatValue<'ctx>,)*
+            ctx: &CodeGenContext<'ctx, '_>
+            $(,$args: FloatValue<'ctx>)*,
             name: Option<&str>,
         ) -> FloatValue<'ctx> {
             const FN_NAME: &str = $extern_fn;
@@ -45,23 +49,24 @@ macro_rules! generate_extern_fn {
             let llvm_f64 = ctx.ctx.f64_type();
             $(debug_assert_eq!($args.get_type(), llvm_f64);)*
 
-            infer_and_call_function(
-                ctx,
-                FN_NAME,
-                Some(llvm_f64.into()),
-                &[$($args.into()),*],
-                name,
-                Some(&|func| {
-                   for attr in [$($attributes),*] {
-                        func.add_attribute(
-                            AttributeLoc::Function,
-                            ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
-                        );
-                    }
-                })
-            )
-            .map(BasicValueEnum::into_float_value)
-            .unwrap()
+            let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+                let fn_type = llvm_f64.fn_type(&[$($args.get_type().into()),*], false);
+                let func = ctx.module.add_function(FN_NAME, fn_type, None);
+                for attr in [$($attributes),*] {
+                    func.add_attribute(
+                        AttributeLoc::Function,
+                        ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
+                    );
+                }
+                func
+            });
+
+            ctx.builder
+                .build_call(extern_fn, &[$($args.into()),*], name.unwrap_or_default())
+                .map(CallSiteValue::try_as_basic_value)
+                .map(|v| v.map_left(BasicValueEnum::into_float_value))
+                .map(Either::unwrap_left)
+                .unwrap()
         }
     };
 }
@@ -110,23 +115,25 @@ pub fn call_ldexp<'ctx>(
     debug_assert_eq!(arg.get_type(), llvm_f64);
     debug_assert_eq!(exp.get_type(), llvm_i32);
 
-    infer_and_call_function(
-        ctx,
-        FN_NAME,
-        Some(llvm_f64.into()),
-        &[arg.into(), exp.into()],
-        name,
-        Some(&|func| {
-            for attr in ["mustprogress", "nofree", "nounwind", "willreturn"] {
-                func.add_attribute(
-                    AttributeLoc::Function,
-                    ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
-                );
-            }
-        }),
-    )
-    .map(BasicValueEnum::into_float_value)
-    .unwrap()
+    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let fn_type = llvm_f64.fn_type(&[llvm_f64.into(), llvm_i32.into()], false);
+        let func = ctx.module.add_function(FN_NAME, fn_type, None);
+        for attr in ["mustprogress", "nofree", "nounwind", "willreturn"] {
+            func.add_attribute(
+                AttributeLoc::Function,
+                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
+            );
+        }
+
+        func
+    });
+
+    ctx.builder
+        .build_call(extern_fn, &[arg.into(), exp.into()], name.unwrap_or_default())
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
 }
 
 /// Macro to generate `np_linalg` and `sp_linalg` functions
@@ -154,27 +161,25 @@ macro_rules! generate_linalg_extern_fn {
     ($fn_name:ident, $extern_fn:literal $(,$input_matrix:ident)*) => {
         #[doc = concat!("Invokes the linalg `", stringify!($extern_fn), " function." )]
         pub fn $fn_name<'ctx>(
-            ctx: &mut CodeGenContext<'ctx, '_>,
-            $($input_matrix: BasicValueEnum<'ctx>,)*
+            ctx: &mut CodeGenContext<'ctx, '_>
+            $(,$input_matrix: BasicValueEnum<'ctx>)*,
             name: Option<&str>,
         ){
             const FN_NAME: &str = $extern_fn;
+            let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+                let fn_type = ctx.ctx.void_type().fn_type(&[$($input_matrix.get_type().into()),*], false);
 
-            infer_and_call_function(
-                ctx,
-                FN_NAME,
-                None,
-                &[$($input_matrix.into(),)*],
-                name,
-                Some(&|func| {
-                   for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
-                        func.add_attribute(
-                            AttributeLoc::Function,
-                            ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
-                        );
-                    }
-                }),
-            );
+                let func = ctx.module.add_function(FN_NAME, fn_type, None);
+                for attr in ["mustprogress", "nofree", "nounwind", "willreturn", "writeonly"] {
+                    func.add_attribute(
+                        AttributeLoc::Function,
+                        ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
+                    );
+                }
+                func
+            });
+
+            ctx.builder.build_call(extern_fn, &[$($input_matrix.into(),)*], name.unwrap_or_default()).unwrap();
         }
     };
 }
@@ -189,3 +194,49 @@ generate_linalg_extern_fn!(call_np_linalg_det, "np_linalg_det", 2);
 generate_linalg_extern_fn!(call_sp_linalg_lu, "sp_linalg_lu", 3);
 generate_linalg_extern_fn!(call_sp_linalg_schur, "sp_linalg_schur", 3);
 generate_linalg_extern_fn!(call_sp_linalg_hessenberg, "sp_linalg_hessenberg", 3);
+
+/// Invokes the `printf` function.
+pub fn call_printf<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    format: &str,
+    args: &[BasicValueEnum<'ctx>],
+) -> IntValue<'ctx> {
+    const FN_NAME: &str = "printf";
+
+    let llvm_i8 = ctx.ctx.i8_type();
+    let llvm_i32 = ctx.ctx.i32_type();
+    let llvm_pi8 = llvm_i8.ptr_type(AddressSpace::default());
+
+    let extern_fn = ctx.module.get_function(FN_NAME).unwrap_or_else(|| {
+        let fn_type = llvm_i32.fn_type(&[llvm_pi8.into()], true);
+        let func = ctx.module.add_function(FN_NAME, fn_type, None);
+        for attr in ["nofree", "nounwind"] {
+            func.add_attribute(
+                AttributeLoc::Function,
+                ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
+            );
+        }
+
+        func
+    });
+
+    let pformat = ctx
+        .builder
+        .build_global_string_ptr(&format!("{format}\0"), "")
+        .map(|v| v.as_basic_value_enum())
+        .map(BasicValueEnum::into_pointer_value)
+        .unwrap();
+
+    let fn_args = once(&pformat.as_basic_value_enum())
+        .chain(args)
+        .copied()
+        .map(BasicValueEnum::into)
+        .collect_vec();
+
+    ctx.builder
+        .build_call(extern_fn, fn_args.as_slice(), "")
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_int_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}

nac3core/src/codegen/generator.rs

@@ -7,7 +7,7 @@ use inkwell::{
 
 use nac3parser::ast::{Expr, Stmt, StrRef};
 
-use super::{bool_to_int_type, expr::*, stmt::*, values::ArraySliceValue, CodeGenContext};
+use super::{bool_to_i1, bool_to_i8, expr::*, stmt::*, values::ArraySliceValue, CodeGenContext};
 use crate::{
     symbol_resolver::ValueEnum,
     toplevel::{DefinitionId, TopLevelDef},
@@ -248,32 +248,22 @@ pub trait CodeGenerator {
         gen_block(self, ctx, stmts)
     }
 
-    /// Converts the value of a boolean-like value `bool_value` into an `i1`.
+    /// See [`bool_to_i1`].
     fn bool_to_i1<'ctx>(
         &self,
         ctx: &CodeGenContext<'ctx, '_>,
         bool_value: IntValue<'ctx>,
     ) -> IntValue<'ctx> {
-        self.bool_to_int_type(ctx, bool_value, ctx.ctx.bool_type())
+        bool_to_i1(&ctx.builder, bool_value)
     }
 
-    /// Converts the value of a boolean-like value `bool_value` into an `i8`.
+    /// See [`bool_to_i8`].
     fn bool_to_i8<'ctx>(
         &self,
         ctx: &CodeGenContext<'ctx, '_>,
         bool_value: IntValue<'ctx>,
     ) -> IntValue<'ctx> {
-        self.bool_to_int_type(ctx, bool_value, ctx.ctx.i8_type())
-    }
-
-    /// See [`bool_to_int_type`].
-    fn bool_to_int_type<'ctx>(
-        &self,
-        ctx: &CodeGenContext<'ctx, '_>,
-        bool_value: IntValue<'ctx>,
-        ty: IntType<'ctx>,
-    ) -> IntValue<'ctx> {
-        bool_to_int_type(&ctx.builder, bool_value, ty)
+        bool_to_i8(&ctx.builder, ctx.ctx, bool_value)
     }
 }
 

nac3core/src/codegen/irrt/list.rs

@@ -1,14 +1,13 @@
 use inkwell::{
     types::BasicTypeEnum,
-    values::{BasicValueEnum, IntValue},
+    values::{BasicValueEnum, CallSiteValue, IntValue},
     AddressSpace, IntPredicate,
 };
+use itertools::Either;
 
 use super::calculate_len_for_slice_range;
 use crate::codegen::{
-    expr::infer_and_call_function,
     macros::codegen_unreachable,
-    stmt::gen_if_callback,
     values::{ArrayLikeValue, ListValue},
     CodeGenContext, CodeGenerator,
 };
@@ -37,6 +36,25 @@ pub fn list_slice_assignment<'ctx, G: CodeGenerator + ?Sized>(
     assert_eq!(src_idx.2.get_type(), llvm_i32);
 
     let (fun_symbol, elem_ptr_type) = ("__nac3_list_slice_assign_var_size", llvm_pi8);
+    let slice_assign_fun = {
+        let ty_vec = vec![
+            llvm_i32.into(),      // dest start idx
+            llvm_i32.into(),      // dest end idx
+            llvm_i32.into(),      // dest step
+            elem_ptr_type.into(), // dest arr ptr
+            llvm_i32.into(),      // dest arr len
+            llvm_i32.into(),      // src start idx
+            llvm_i32.into(),      // src end idx
+            llvm_i32.into(),      // src step
+            elem_ptr_type.into(), // src arr ptr
+            llvm_i32.into(),      // src arr len
+            llvm_i32.into(),      // size
+        ];
+        ctx.module.get_function(fun_symbol).unwrap_or_else(|| {
+            let fn_t = llvm_i32.fn_type(ty_vec.as_slice(), false);
+            ctx.module.add_function(fun_symbol, fn_t, None)
+        })
+    };
 
     let zero = llvm_i32.const_zero();
     let one = llvm_i32.const_int(1, false);
@@ -109,7 +127,7 @@ pub fn list_slice_assignment<'ctx, G: CodeGenerator + ?Sized>(
     );
 
     let new_len = {
-        let args = [
+        let args = vec![
             dest_idx.0.into(),   // dest start idx
             dest_idx.1.into(),   // dest end idx
             dest_idx.2.into(),   // dest step
@@ -132,35 +150,25 @@ pub fn list_slice_assignment<'ctx, G: CodeGenerator + ?Sized>(
             }
             .into(),
         ];
-        infer_and_call_function(
-            ctx,
-            fun_symbol,
-            Some(llvm_i32.into()),
-            &args,
-            Some("slice_assign"),
-            None,
-        )
-        .map(BasicValueEnum::into_int_value)
-        .unwrap()
+        ctx.builder
+            .build_call(slice_assign_fun, args.as_slice(), "slice_assign")
+            .map(CallSiteValue::try_as_basic_value)
+            .map(|v| v.map_left(BasicValueEnum::into_int_value))
+            .map(Either::unwrap_left)
+            .unwrap()
     };
 
     // update length
-    gen_if_callback(
-        generator,
-        ctx,
-        |_, ctx| {
-            Ok(ctx
-                .builder
-                .build_int_compare(IntPredicate::NE, new_len, dest_len, "need_update")
-                .unwrap())
-        },
-        |_, ctx| {
-            let new_len =
-                ctx.builder.build_int_z_extend_or_bit_cast(new_len, llvm_usize, "new_len").unwrap();
-            dest_arr.store_size(ctx, new_len);
-            Ok(())
-        },
-        |_, _| Ok(()),
-    )
-    .unwrap();
+    let need_update =
+        ctx.builder.build_int_compare(IntPredicate::NE, new_len, dest_len, "need_update").unwrap();
+    let current = ctx.builder.get_insert_block().unwrap().get_parent().unwrap();
+    let update_bb = ctx.ctx.append_basic_block(current, "update");
+    let cont_bb = ctx.ctx.append_basic_block(current, "cont");
+    ctx.builder.build_conditional_branch(need_update, update_bb, cont_bb).unwrap();
+    ctx.builder.position_at_end(update_bb);
+    let new_len =
+        ctx.builder.build_int_z_extend_or_bit_cast(new_len, llvm_usize, "new_len").unwrap();
+    dest_arr.store_size(ctx, new_len);
+    ctx.builder.build_unconditional_branch(cont_bb).unwrap();
+    ctx.builder.position_at_end(cont_bb);
 }

nac3core/src/codegen/irrt/math.rs

@@ -1,10 +1,10 @@
 use inkwell::{
-    values::{BasicValueEnum, FloatValue, IntValue},
+    values::{BasicValueEnum, CallSiteValue, FloatValue, IntValue},
     IntPredicate,
 };
+use itertools::Either;
 
 use crate::codegen::{
-    expr::infer_and_call_function,
     macros::codegen_unreachable,
     {CodeGenContext, CodeGenerator},
 };
@@ -18,16 +18,18 @@ pub fn integer_power<'ctx, G: CodeGenerator + ?Sized>(
     exp: IntValue<'ctx>,
     signed: bool,
 ) -> IntValue<'ctx> {
-    let base_type = base.get_type();
-
-    let symbol = match (base_type.get_bit_width(), exp.get_type().get_bit_width(), signed) {
+    let symbol = match (base.get_type().get_bit_width(), exp.get_type().get_bit_width(), signed) {
         (32, 32, true) => "__nac3_int_exp_int32_t",
         (64, 64, true) => "__nac3_int_exp_int64_t",
         (32, 32, false) => "__nac3_int_exp_uint32_t",
         (64, 64, false) => "__nac3_int_exp_uint64_t",
         _ => codegen_unreachable!(ctx),
     };
-
+    let base_type = base.get_type();
+    let pow_fun = ctx.module.get_function(symbol).unwrap_or_else(|| {
+        let fn_type = base_type.fn_type(&[base_type.into(), base_type.into()], false);
+        ctx.module.add_function(symbol, fn_type, None)
+    });
     // throw exception when exp < 0
     let ge_zero = ctx
         .builder
@@ -46,17 +48,12 @@ pub fn integer_power<'ctx, G: CodeGenerator + ?Sized>(
         [None, None, None],
         ctx.current_loc,
     );
-
-    infer_and_call_function(
-        ctx,
-        symbol,
-        Some(base_type.into()),
-        &[base.into(), exp.into()],
-        Some("call_int_pow"),
-        None,
-    )
-    .map(BasicValueEnum::into_int_value)
-    .unwrap()
+    ctx.builder
+        .build_call(pow_fun, &[base.into(), exp.into()], "call_int_pow")
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_int_value))
+        .map(Either::unwrap_left)
+        .unwrap()
 }
 
 /// Generates a call to `isinf` in IR. Returns an `i1` representing the result.
@@ -70,17 +67,20 @@ pub fn call_isinf<'ctx, G: CodeGenerator + ?Sized>(
 
     assert_eq!(v.get_type(), llvm_f64);
 
-    infer_and_call_function(
-        ctx,
-        "__nac3_isinf",
-        Some(llvm_i32.into()),
-        &[v.into()],
-        Some("isinf"),
-        None,
-    )
-    .map(BasicValueEnum::into_int_value)
-    .map(|ret| generator.bool_to_i1(ctx, ret))
-    .unwrap()
+    let intrinsic_fn = ctx.module.get_function("__nac3_isinf").unwrap_or_else(|| {
+        let fn_type = llvm_i32.fn_type(&[llvm_f64.into()], false);
+        ctx.module.add_function("__nac3_isinf", fn_type, None)
+    });
+
+    let ret = ctx
+        .builder
+        .build_call(intrinsic_fn, &[v.into()], "isinf")
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_int_value))
+        .map(Either::unwrap_left)
+        .unwrap();
+
+    generator.bool_to_i1(ctx, ret)
 }
 
 /// Generates a call to `isnan` in IR. Returns an `i1` representing the result.
@@ -94,17 +94,20 @@ pub fn call_isnan<'ctx, G: CodeGenerator + ?Sized>(
 
     assert_eq!(v.get_type(), llvm_f64);
 
-    infer_and_call_function(
-        ctx,
-        "__nac3_isnan",
-        Some(llvm_i32.into()),
-        &[v.into()],
-        Some("isnan"),
-        None,
-    )
-    .map(BasicValueEnum::into_int_value)
-    .map(|ret| generator.bool_to_i1(ctx, ret))
-    .unwrap()
+    let intrinsic_fn = ctx.module.get_function("__nac3_isnan").unwrap_or_else(|| {
+        let fn_type = llvm_i32.fn_type(&[llvm_f64.into()], false);
+        ctx.module.add_function("__nac3_isnan", fn_type, None)
+    });
+
+    let ret = ctx
+        .builder
+        .build_call(intrinsic_fn, &[v.into()], "isnan")
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_int_value))
+        .map(Either::unwrap_left)
+        .unwrap();
+
+    generator.bool_to_i1(ctx, ret)
 }
 
 /// Generates a call to `gamma` in IR. Returns an `f64` representing the result.
@@ -113,16 +116,17 @@ pub fn call_gamma<'ctx>(ctx: &CodeGenContext<'ctx, '_>, v: FloatValue<'ctx>) ->
 
     assert_eq!(v.get_type(), llvm_f64);
 
-    infer_and_call_function(
-        ctx,
-        "__nac3_gamma",
-        Some(llvm_f64.into()),
-        &[v.into()],
-        Some("gamma"),
-        None,
-    )
-    .map(BasicValueEnum::into_float_value)
-    .unwrap()
+    let intrinsic_fn = ctx.module.get_function("__nac3_gamma").unwrap_or_else(|| {
+        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
+        ctx.module.add_function("__nac3_gamma", fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[v.into()], "gamma")
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
 }
 
 /// Generates a call to `gammaln` in IR. Returns an `f64` representing the result.
@@ -131,16 +135,17 @@ pub fn call_gammaln<'ctx>(ctx: &CodeGenContext<'ctx, '_>, v: FloatValue<'ctx>) -
 
     assert_eq!(v.get_type(), llvm_f64);
 
-    infer_and_call_function(
-        ctx,
-        "__nac3_gammaln",
-        Some(llvm_f64.into()),
-        &[v.into()],
-        Some("gammaln"),
-        None,
-    )
-    .map(BasicValueEnum::into_float_value)
-    .unwrap()
+    let intrinsic_fn = ctx.module.get_function("__nac3_gammaln").unwrap_or_else(|| {
+        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
+        ctx.module.add_function("__nac3_gammaln", fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[v.into()], "gammaln")
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
+        .unwrap()
 }
 
 /// Generates a call to `j0` in IR. Returns an `f64` representing the result.
@@ -149,7 +154,15 @@ pub fn call_j0<'ctx>(ctx: &CodeGenContext<'ctx, '_>, v: FloatValue<'ctx>) -> Flo
 
     assert_eq!(v.get_type(), llvm_f64);
 
-    infer_and_call_function(ctx, "__nac3_j0", Some(llvm_f64.into()), &[v.into()], Some("j0"), None)
-        .map(BasicValueEnum::into_float_value)
+    let intrinsic_fn = ctx.module.get_function("__nac3_j0").unwrap_or_else(|| {
+        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
+        ctx.module.add_function("__nac3_j0", fn_type, None)
+    });
+
+    ctx.builder
+        .build_call(intrinsic_fn, &[v.into()], "j0")
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_float_value))
+        .map(Either::unwrap_left)
         .unwrap()
 }

nac3core/src/codegen/irrt/ndarray/basic.rs

@@ -1,11 +1,13 @@
 use inkwell::{
+    types::BasicTypeEnum,
     values::{BasicValueEnum, IntValue, PointerValue},
     AddressSpace,
 };
 
 use crate::codegen::{
-    expr::infer_and_call_function,
+    expr::{create_and_call_function, infer_and_call_function},
     irrt::get_usize_dependent_function_name,
+    types::ProxyType,
     values::{ndarray::NDArrayValue, ProxyValue, TypedArrayLikeAccessor},
     CodeGenContext, CodeGenerator,
 };
@@ -19,17 +21,24 @@ pub fn call_nac3_ndarray_util_assert_shape_no_negative<'ctx, G: CodeGenerator +
     shape: &impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>,
 ) {
     let llvm_usize = ctx.get_size_type();
+    let llvm_pusize = llvm_usize.ptr_type(AddressSpace::default());
 
-    assert_eq!(shape.element_type(ctx, generator), llvm_usize.into());
+    assert_eq!(
+        BasicTypeEnum::try_from(shape.element_type(ctx, generator)).unwrap(),
+        llvm_usize.into()
+    );
 
     let name =
         get_usize_dependent_function_name(ctx, "__nac3_ndarray_util_assert_shape_no_negative");
 
-    infer_and_call_function(
+    create_and_call_function(
         ctx,
         &name,
         Some(llvm_usize.into()),
-        &[shape.size(ctx, generator).into(), shape.base_ptr(ctx, generator).into()],
+        &[
+            (llvm_usize.into(), shape.size(ctx, generator).into()),
+            (llvm_pusize.into(), shape.base_ptr(ctx, generator).into()),
+        ],
         None,
         None,
     );
@@ -46,22 +55,29 @@ pub fn call_nac3_ndarray_util_assert_output_shape_same<'ctx, G: CodeGenerator +
     output_shape: &impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>,
 ) {
     let llvm_usize = ctx.get_size_type();
+    let llvm_pusize = llvm_usize.ptr_type(AddressSpace::default());
 
-    assert_eq!(ndarray_shape.element_type(ctx, generator), llvm_usize.into());
-    assert_eq!(output_shape.element_type(ctx, generator), llvm_usize.into());
+    assert_eq!(
+        BasicTypeEnum::try_from(ndarray_shape.element_type(ctx, generator)).unwrap(),
+        llvm_usize.into()
+    );
+    assert_eq!(
+        BasicTypeEnum::try_from(output_shape.element_type(ctx, generator)).unwrap(),
+        llvm_usize.into()
+    );
 
     let name =
         get_usize_dependent_function_name(ctx, "__nac3_ndarray_util_assert_output_shape_same");
 
-    infer_and_call_function(
+    create_and_call_function(
         ctx,
         &name,
         Some(llvm_usize.into()),
         &[
-            ndarray_shape.size(ctx, generator).into(),
-            ndarray_shape.base_ptr(ctx, generator).into(),
-            output_shape.size(ctx, generator).into(),
-            output_shape.base_ptr(ctx, generator).into(),
+            (llvm_usize.into(), ndarray_shape.size(ctx, generator).into()),
+            (llvm_pusize.into(), ndarray_shape.base_ptr(ctx, generator).into()),
+            (llvm_usize.into(), output_shape.size(ctx, generator).into()),
+            (llvm_pusize.into(), output_shape.base_ptr(ctx, generator).into()),
         ],
         None,
         None,
@@ -77,14 +93,15 @@ pub fn call_nac3_ndarray_size<'ctx>(
     ndarray: NDArrayValue<'ctx>,
 ) -> IntValue<'ctx> {
     let llvm_usize = ctx.get_size_type();
+    let llvm_ndarray = ndarray.get_type();
 
     let name = get_usize_dependent_function_name(ctx, "__nac3_ndarray_size");
 
-    infer_and_call_function(
+    create_and_call_function(
         ctx,
         &name,
         Some(llvm_usize.into()),
-        &[ndarray.as_abi_value(ctx).into()],
+        &[(llvm_ndarray.as_abi_type().into(), ndarray.as_abi_value(ctx).into())],
         Some("size"),
         None,
     )
@@ -101,14 +118,15 @@ pub fn call_nac3_ndarray_nbytes<'ctx>(
     ndarray: NDArrayValue<'ctx>,
 ) -> IntValue<'ctx> {
     let llvm_usize = ctx.get_size_type();
+    let llvm_ndarray = ndarray.get_type();
 
     let name = get_usize_dependent_function_name(ctx, "__nac3_ndarray_nbytes");
 
-    infer_and_call_function(
+    create_and_call_function(
         ctx,
         &name,
         Some(llvm_usize.into()),
-        &[ndarray.as_abi_value(ctx).into()],
+        &[(llvm_ndarray.as_abi_type().into(), ndarray.as_abi_value(ctx).into())],
         Some("nbytes"),
         None,
     )
@@ -125,14 +143,15 @@ pub fn call_nac3_ndarray_len<'ctx>(
     ndarray: NDArrayValue<'ctx>,
 ) -> IntValue<'ctx> {
     let llvm_usize = ctx.get_size_type();
+    let llvm_ndarray = ndarray.get_type();
 
     let name = get_usize_dependent_function_name(ctx, "__nac3_ndarray_len");
 
-    infer_and_call_function(
+    create_and_call_function(
         ctx,
         &name,
         Some(llvm_usize.into()),
-        &[ndarray.as_abi_value(ctx).into()],
+        &[(llvm_ndarray.as_abi_type().into(), ndarray.as_abi_value(ctx).into())],
         Some("len"),
         None,
     )
@@ -148,14 +167,15 @@ pub fn call_nac3_ndarray_is_c_contiguous<'ctx>(
     ndarray: NDArrayValue<'ctx>,
 ) -> IntValue<'ctx> {
     let llvm_i1 = ctx.ctx.bool_type();
+    let llvm_ndarray = ndarray.get_type();
 
     let name = get_usize_dependent_function_name(ctx, "__nac3_ndarray_is_c_contiguous");
 
-    infer_and_call_function(
+    create_and_call_function(
         ctx,
         &name,
         Some(llvm_i1.into()),
-        &[ndarray.as_abi_value(ctx).into()],
+        &[(llvm_ndarray.as_abi_type().into(), ndarray.as_abi_value(ctx).into())],
         Some("is_c_contiguous"),
         None,
     )
@@ -174,16 +194,20 @@ pub fn call_nac3_ndarray_get_nth_pelement<'ctx>(
     let llvm_i8 = ctx.ctx.i8_type();
     let llvm_pi8 = llvm_i8.ptr_type(AddressSpace::default());
     let llvm_usize = ctx.get_size_type();
+    let llvm_ndarray = ndarray.get_type();
 
     assert_eq!(index.get_type(), llvm_usize);
 
     let name = get_usize_dependent_function_name(ctx, "__nac3_ndarray_get_nth_pelement");
 
-    infer_and_call_function(
+    create_and_call_function(
         ctx,
         &name,
         Some(llvm_pi8.into()),
-        &[ndarray.as_abi_value(ctx).into(), index.into()],
+        &[
+            (llvm_ndarray.as_abi_type().into(), ndarray.as_abi_value(ctx).into()),
+            (llvm_usize.into(), index.into()),
+        ],
         Some("pelement"),
         None,
     )
@@ -205,16 +229,24 @@ pub fn call_nac3_ndarray_get_pelement_by_indices<'ctx, G: CodeGenerator + ?Sized
     let llvm_i8 = ctx.ctx.i8_type();
     let llvm_pi8 = llvm_i8.ptr_type(AddressSpace::default());
     let llvm_usize = ctx.get_size_type();
+    let llvm_pusize = llvm_usize.ptr_type(AddressSpace::default());
+    let llvm_ndarray = ndarray.get_type();
 
-    assert_eq!(indices.element_type(ctx, generator), llvm_usize.into());
+    assert_eq!(
+        BasicTypeEnum::try_from(indices.element_type(ctx, generator)).unwrap(),
+        llvm_usize.into()
+    );
 
     let name = get_usize_dependent_function_name(ctx, "__nac3_ndarray_get_pelement_by_indices");
 
-    infer_and_call_function(
+    create_and_call_function(
         ctx,
         &name,
         Some(llvm_pi8.into()),
-        &[ndarray.as_abi_value(ctx).into(), indices.base_ptr(ctx, generator).into()],
+        &[
+            (llvm_ndarray.as_abi_type().into(), ndarray.as_abi_value(ctx).into()),
+            (llvm_pusize.into(), indices.base_ptr(ctx, generator).into()),
+        ],
         Some("pelement"),
         None,
     )
@@ -229,9 +261,18 @@ pub fn call_nac3_ndarray_set_strides_by_shape<'ctx>(
     ctx: &CodeGenContext<'ctx, '_>,
     ndarray: NDArrayValue<'ctx>,
 ) {
+    let llvm_ndarray = ndarray.get_type();
+
     let name = get_usize_dependent_function_name(ctx, "__nac3_ndarray_set_strides_by_shape");
 
-    infer_and_call_function(ctx, &name, None, &[ndarray.as_abi_value(ctx).into()], None, None);
+    create_and_call_function(
+        ctx,
+        &name,
+        None,
+        &[(llvm_ndarray.as_abi_type().into(), ndarray.as_abi_value(ctx).into())],
+        None,
+        None,
+    );
 }
 
 /// Generates a call to `__nac3_ndarray_copy_data`.

nac3core/src/codegen/irrt/ndarray/iter.rs

@@ -1,8 +1,13 @@
-use inkwell::values::{BasicValueEnum, IntValue};
+use inkwell::{
+    types::BasicTypeEnum,
+    values::{BasicValueEnum, IntValue},
+    AddressSpace,
+};
 
 use crate::codegen::{
-    expr::infer_and_call_function,
+    expr::{create_and_call_function, infer_and_call_function},
     irrt::get_usize_dependent_function_name,
+    types::ProxyType,
     values::{
         ndarray::{NDArrayValue, NDIterValue},
         ProxyValue, TypedArrayLikeAccessor,
@@ -21,19 +26,23 @@ pub fn call_nac3_nditer_initialize<'ctx, G: CodeGenerator + ?Sized>(
     indices: &impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>,
 ) {
     let llvm_usize = ctx.get_size_type();
+    let llvm_pusize = llvm_usize.ptr_type(AddressSpace::default());
 
-    assert_eq!(indices.element_type(ctx, generator), llvm_usize.into());
+    assert_eq!(
+        BasicTypeEnum::try_from(indices.element_type(ctx, generator)).unwrap(),
+        llvm_usize.into()
+    );
 
     let name = get_usize_dependent_function_name(ctx, "__nac3_nditer_initialize");
 
-    infer_and_call_function(
+    create_and_call_function(
         ctx,
         &name,
         None,
         &[
-            iter.as_abi_value(ctx).into(),
-            ndarray.as_abi_value(ctx).into(),
-            indices.base_ptr(ctx, generator).into(),
+            (iter.get_type().as_abi_type().into(), iter.as_abi_value(ctx).into()),
+            (ndarray.get_type().as_abi_type().into(), ndarray.as_abi_value(ctx).into()),
+            (llvm_pusize.into(), indices.base_ptr(ctx, generator).into()),
         ],
         None,
         None,

nac3core/src/codegen/irrt/ndarray/matmul.rs

@@ -1,4 +1,4 @@
-use inkwell::values::IntValue;
+use inkwell::{types::BasicTypeEnum, values::IntValue};
 
 use crate::codegen::{
     expr::infer_and_call_function, irrt::get_usize_dependent_function_name,
@@ -22,12 +22,26 @@ pub fn call_nac3_ndarray_matmul_calculate_shapes<'ctx, G: CodeGenerator + ?Sized
 ) {
     let llvm_usize = ctx.get_size_type();
 
-    assert_eq!(a_shape.element_type(ctx, generator), llvm_usize.into());
-    assert_eq!(b_shape.element_type(ctx, generator), llvm_usize.into());
-    assert_eq!(final_ndims.get_type(), llvm_usize);
-    assert_eq!(new_a_shape.element_type(ctx, generator), llvm_usize.into());
-    assert_eq!(new_b_shape.element_type(ctx, generator), llvm_usize.into());
-    assert_eq!(dst_shape.element_type(ctx, generator), llvm_usize.into());
+    assert_eq!(
+        BasicTypeEnum::try_from(a_shape.element_type(ctx, generator)).unwrap(),
+        llvm_usize.into()
+    );
+    assert_eq!(
+        BasicTypeEnum::try_from(b_shape.element_type(ctx, generator)).unwrap(),
+        llvm_usize.into()
+    );
+    assert_eq!(
+        BasicTypeEnum::try_from(new_a_shape.element_type(ctx, generator)).unwrap(),
+        llvm_usize.into()
+    );
+    assert_eq!(
+        BasicTypeEnum::try_from(new_b_shape.element_type(ctx, generator)).unwrap(),
+        llvm_usize.into()
+    );
+    assert_eq!(
+        BasicTypeEnum::try_from(dst_shape.element_type(ctx, generator)).unwrap(),
+        llvm_usize.into()
+    );
 
     let name = get_usize_dependent_function_name(ctx, "__nac3_ndarray_matmul_calculate_shapes");
 

nac3core/src/codegen/irrt/range.rs

@@ -1,9 +1,10 @@
 use inkwell::{
-    values::{BasicValueEnum, IntValue},
+    values::{BasicValueEnum, CallSiteValue, IntValue},
     IntPredicate,
 };
+use itertools::Either;
 
-use crate::codegen::{expr::infer_and_call_function, CodeGenContext, CodeGenerator};
+use crate::codegen::{CodeGenContext, CodeGenerator};
 
 /// Invokes the `__nac3_range_slice_len` in IRRT.
 ///
@@ -22,10 +23,16 @@ pub fn calculate_len_for_slice_range<'ctx, G: CodeGenerator + ?Sized>(
     const SYMBOL: &str = "__nac3_range_slice_len";
 
     let llvm_i32 = ctx.ctx.i32_type();
+
     assert_eq!(start.get_type(), llvm_i32);
     assert_eq!(end.get_type(), llvm_i32);
     assert_eq!(step.get_type(), llvm_i32);
 
+    let len_func = ctx.module.get_function(SYMBOL).unwrap_or_else(|| {
+        let fn_t = llvm_i32.fn_type(&[llvm_i32.into(), llvm_i32.into(), llvm_i32.into()], false);
+        ctx.module.add_function(SYMBOL, fn_t, None)
+    });
+
     // assert step != 0, throw exception if not
     let not_zero = ctx
         .builder
@@ -40,14 +47,10 @@ pub fn calculate_len_for_slice_range<'ctx, G: CodeGenerator + ?Sized>(
         ctx.current_loc,
     );
 
-    infer_and_call_function(
-        ctx,
-        SYMBOL,
-        Some(llvm_i32.into()),
-        &[start.into(), end.into(), step.into()],
-        Some("calc_len"),
-        None,
-    )
-    .map(BasicValueEnum::into_int_value)
-    .unwrap()
+    ctx.builder
+        .build_call(len_func, &[start.into(), end.into(), step.into()], "calc_len")
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_int_value))
+        .map(Either::unwrap_left)
+        .unwrap()
 }

nac3core/src/codegen/irrt/slice.rs

@@ -1,9 +1,10 @@
-use inkwell::values::{BasicValueEnum, IntValue};
+use inkwell::values::{BasicValueEnum, CallSiteValue, IntValue};
+use itertools::Either;
 
 use nac3parser::ast::Expr;
 
 use crate::{
-    codegen::{expr::infer_and_call_function, CodeGenContext, CodeGenerator},
+    codegen::{CodeGenContext, CodeGenerator},
     typecheck::typedef::Type,
 };
 
@@ -16,26 +17,23 @@ pub fn handle_slice_index_bound<'ctx, G: CodeGenerator>(
     length: IntValue<'ctx>,
 ) -> Result<Option<IntValue<'ctx>>, String> {
     const SYMBOL: &str = "__nac3_slice_index_bound";
-
-    let llvm_i32 = ctx.ctx.i32_type();
-    assert_eq!(length.get_type(), llvm_i32);
+    let func = ctx.module.get_function(SYMBOL).unwrap_or_else(|| {
+        let i32_t = ctx.ctx.i32_type();
+        let fn_t = i32_t.fn_type(&[i32_t.into(), i32_t.into()], false);
+        ctx.module.add_function(SYMBOL, fn_t, None)
+    });
 
     let i = if let Some(v) = generator.gen_expr(ctx, i)? {
         v.to_basic_value_enum(ctx, generator, i.custom.unwrap())?
     } else {
         return Ok(None);
     };
-
     Ok(Some(
-        infer_and_call_function(
-            ctx,
-            SYMBOL,
-            Some(llvm_i32.into()),
-            &[i, length.into()],
-            Some("bounded_ind"),
-            None,
-        )
-        .map(BasicValueEnum::into_int_value)
-        .unwrap(),
+        ctx.builder
+            .build_call(func, &[i.into(), length.into()], "bounded_ind")
+            .map(CallSiteValue::try_as_basic_value)
+            .map(|v| v.map_left(BasicValueEnum::into_int_value))
+            .map(Either::unwrap_left)
+            .unwrap(),
     ))
 }

nac3core/src/codegen/irrt/string.rs

@@ -1,31 +1,45 @@
-use inkwell::values::{BasicValueEnum, IntValue};
+use inkwell::values::{BasicValueEnum, CallSiteValue, IntValue, PointerValue};
+use itertools::Either;
 
 use super::get_usize_dependent_function_name;
-use crate::codegen::{expr::infer_and_call_function, values::StringValue, CodeGenContext};
+use crate::codegen::CodeGenContext;
 
 /// Generates a call to string equality comparison. Returns an `i1` representing whether the strings are equal.
 pub fn call_string_eq<'ctx>(
     ctx: &CodeGenContext<'ctx, '_>,
-    str1: StringValue<'ctx>,
-    str2: StringValue<'ctx>,
+    str1_ptr: PointerValue<'ctx>,
+    str1_len: IntValue<'ctx>,
+    str2_ptr: PointerValue<'ctx>,
+    str2_len: IntValue<'ctx>,
 ) -> IntValue<'ctx> {
     let llvm_i1 = ctx.ctx.bool_type();
 
     let func_name = get_usize_dependent_function_name(ctx, "nac3_str_eq");
 
-    infer_and_call_function(
-        ctx,
-        &func_name,
-        Some(llvm_i1.into()),
-        &[
-            str1.extract_ptr(ctx).into(),
-            str1.extract_len(ctx).into(),
-            str2.extract_ptr(ctx).into(),
-            str2.extract_len(ctx).into(),
-        ],
-        Some("str_eq_call"),
-        None,
-    )
-    .map(BasicValueEnum::into_int_value)
-    .unwrap()
+    let func = ctx.module.get_function(&func_name).unwrap_or_else(|| {
+        ctx.module.add_function(
+            &func_name,
+            llvm_i1.fn_type(
+                &[
+                    str1_ptr.get_type().into(),
+                    str1_len.get_type().into(),
+                    str2_ptr.get_type().into(),
+                    str2_len.get_type().into(),
+                ],
+                false,
+            ),
+            None,
+        )
+    });
+
+    ctx.builder
+        .build_call(
+            func,
+            &[str1_ptr.into(), str1_len.into(), str2_ptr.into(), str2_len.into()],
+            "str_eq_call",
+        )
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_int_value))
+        .map(Either::unwrap_left)
+        .unwrap()
 }

nac3core/src/codegen/mod.rs

@@ -43,9 +43,8 @@ use crate::{
 };
 use concrete_type::{ConcreteType, ConcreteTypeEnum, ConcreteTypeStore};
 pub use generator::{CodeGenerator, DefaultCodeGenerator};
-use types::{
-    ndarray::NDArrayType, ListType, OptionType, ProxyType, RangeType, StringType, TupleType,
-};
+use tracert::{TraceRuntimeConfig, TraceRuntimeState};
+use types::{ndarray::NDArrayType, ListType, ProxyType, RangeType, TupleType};
 
 pub mod builtin_fns;
 pub mod concrete_type;
@@ -56,6 +55,7 @@ pub mod irrt;
 pub mod llvm_intrinsics;
 pub mod numpy;
 pub mod stmt;
+pub mod tracert;
 pub mod types;
 pub mod values;
 
@@ -227,6 +227,8 @@ pub struct CodeGenContext<'ctx, 'a> {
     /// See [`need_sret`].
     pub need_sret: bool,
 
+    pub tracert_state: Option<TraceRuntimeState>,
+
     /// The current source location.
     pub current_loc: Location,
 
@@ -293,6 +295,8 @@ pub struct WorkerRegistry {
 
     /// LLVM-related options for code generation.
     pub llvm_options: CodeGenLLVMOptions,
+
+    tracert_config: TraceRuntimeConfig,
 }
 
 impl WorkerRegistry {
@@ -302,6 +306,7 @@ impl WorkerRegistry {
         generators: Vec<Box<G>>,
         top_level_ctx: Arc<TopLevelContext>,
         llvm_options: &CodeGenLLVMOptions,
+        tracert_config: &TraceRuntimeConfig,
         f: &Arc<WithCall>,
     ) -> (Arc<WorkerRegistry>, Vec<thread::JoinHandle<()>>) {
         let (sender, receiver) = unbounded();
@@ -323,6 +328,7 @@ impl WorkerRegistry {
             wait_condvar,
             top_level_ctx,
             llvm_options: llvm_options.clone(),
+            tracert_config: tracert_config.clone(),
         });
 
         let mut handles = Vec::new();
@@ -540,7 +546,7 @@ fn get_llvm_type<'ctx, G: CodeGenerator + ?Sized>(
                 if PrimDef::contains_id(*obj_id) {
                     return match &*unifier.get_ty_immutable(ty) {
                         TObj { obj_id, params, .. } if *obj_id == PrimDef::Option.id() => {
-                            let element_type = get_llvm_type(
+                            get_llvm_type(
                                 ctx,
                                 module,
                                 generator,
@@ -548,9 +554,9 @@ fn get_llvm_type<'ctx, G: CodeGenerator + ?Sized>(
                                 top_level,
                                 type_cache,
                                 *params.iter().next().unwrap().1,
-                            );
-
-                            OptionType::new_with_generator(generator, ctx, &element_type).as_abi_type().into()
+                            )
+                            .ptr_type(AddressSpace::default())
+                            .into()
                         }
 
                         TObj { obj_id, params, .. } if *obj_id == PrimDef::List.id() => {
@@ -788,7 +794,19 @@ pub fn gen_func_impl<
         (primitives.float, context.f64_type().into()),
         (primitives.bool, context.i8_type().into()),
         (primitives.str, {
-            StringType::new_with_generator(generator, context).as_abi_type().into()
+            let name = "str";
+            match module.get_struct_type(name) {
+                None => {
+                    let str_type = context.opaque_struct_type("str");
+                    let fields = [
+                        context.i8_type().ptr_type(AddressSpace::default()).into(),
+                        generator.get_size_type(context).into(),
+                    ];
+                    str_type.set_body(&fields, false);
+                    str_type.into()
+                }
+                Some(t) => t.as_basic_type_enum(),
+            }
         }),
         (primitives.range, RangeType::new_with_generator(generator, context).as_abi_type().into()),
         (primitives.exception, {
@@ -923,7 +941,7 @@ pub fn gen_func_impl<
             let param_val = param.into_int_value();
 
             if expected_ty.get_bit_width() == 8 && param_val.get_type().get_bit_width() == 1 {
-                bool_to_int_type(&builder, param_val, context.i8_type())
+                bool_to_i8(&builder, context, param_val)
             } else {
                 param_val
             }
@@ -1027,6 +1045,13 @@ pub fn gen_func_impl<
         unifier,
         static_value_store,
         need_sret: has_sret,
+        tracert_state: if cfg!(feature = "tracing")
+            || registry.tracert_config.enabled_tags.is_empty()
+        {
+            None
+        } else {
+            Some(TraceRuntimeState::create(registry.tracert_config.clone()))
+        },
         current_loc: Location::default(),
         debug_info: (dibuilder, compile_unit, func_scope.as_debug_info_scope()),
         llvm_usize: OnceCell::default(),
@@ -1093,29 +1118,43 @@ pub fn gen_func<'ctx, G: CodeGenerator>(
     })
 }
 
-/// Converts the value of a boolean-like value `value` into an arbitrary [`IntType`].
-///
-/// This has the same semantics as `(ty)(value != 0)` in C.
-///
-/// The returned value is guaranteed to either be `0` or `1`, except for `ty == i1` where only the
-/// least-significant bit would be guaranteed to be `0` or `1`.
-fn bool_to_int_type<'ctx>(
+/// Converts the value of a boolean-like value `bool_value` into an `i1`.
+fn bool_to_i1<'ctx>(builder: &Builder<'ctx>, bool_value: IntValue<'ctx>) -> IntValue<'ctx> {
+    if bool_value.get_type().get_bit_width() == 1 {
+        bool_value
+    } else {
+        builder
+            .build_int_compare(
+                IntPredicate::NE,
+                bool_value,
+                bool_value.get_type().const_zero(),
+                "tobool",
+            )
+            .unwrap()
+    }
+}
+
+/// Converts the value of a boolean-like value `bool_value` into an `i8`.
+fn bool_to_i8<'ctx>(
     builder: &Builder<'ctx>,
-    value: IntValue<'ctx>,
-    ty: IntType<'ctx>,
+    ctx: &'ctx Context,
+    bool_value: IntValue<'ctx>,
 ) -> IntValue<'ctx> {
-    // i1 -> i1    : %value                                     ; no-op
-    // i1 -> i<N>  : zext i1 %value to i<N>                     ; guaranteed to be 0 or 1 - see docs
-    // i<M> -> i<N>: zext i1 (icmp eq i<M> %value, 0) to i<N>   ; same as i<M> -> i1 -> i<N>
-    match (value.get_type().get_bit_width(), ty.get_bit_width()) {
-        (1, 1) => value,
-        (1, _) => builder.build_int_z_extend(value, ty, "frombool").unwrap(),
-        _ => bool_to_int_type(
+    let value_bits = bool_value.get_type().get_bit_width();
+    match value_bits {
+        8 => bool_value,
+        1 => builder.build_int_z_extend(bool_value, ctx.i8_type(), "frombool").unwrap(),
+        _ => bool_to_i8(
             builder,
+            ctx,
             builder
-                .build_int_compare(IntPredicate::NE, value, value.get_type().const_zero(), "tobool")
+                .build_int_compare(
+                    IntPredicate::NE,
+                    bool_value,
+                    bool_value.get_type().const_zero(),
+                    "",
+                )
                 .unwrap(),
-            ty,
         ),
     }
 }

nac3core/src/codegen/stmt.rs

@@ -17,10 +17,10 @@ use super::{
     gen_in_range_check,
     irrt::{handle_slice_indices, list_slice_assignment},
     macros::codegen_unreachable,
-    types::{ndarray::NDArrayType, ExceptionType, RangeType},
+    types::{ndarray::NDArrayType, RangeType},
     values::{
         ndarray::{RustNDIndex, ScalarOrNDArray},
-        ArrayLikeIndexer, ArraySliceValue, ExceptionValue, ListValue, ProxyValue,
+        ArrayLikeIndexer, ArraySliceValue, ListValue, ProxyValue,
     },
     CodeGenContext, CodeGenerator,
 };
@@ -1337,19 +1337,43 @@ pub fn exn_constructor<'ctx>(
 pub fn gen_raise<'ctx, G: CodeGenerator + ?Sized>(
     generator: &mut G,
     ctx: &mut CodeGenContext<'ctx, '_>,
-    exception: Option<&ExceptionValue<'ctx>>,
+    exception: Option<&BasicValueEnum<'ctx>>,
     loc: Location,
 ) {
     if let Some(exception) = exception {
-        exception.store_location(generator, ctx, loc);
+        unsafe {
+            let int32 = ctx.ctx.i32_type();
+            let zero = int32.const_zero();
+            let exception = exception.into_pointer_value();
+            let file_ptr = ctx
+                .builder
+                .build_in_bounds_gep(exception, &[zero, int32.const_int(1, false)], "file_ptr")
+                .unwrap();
+            let filename = ctx.gen_string(generator, loc.file.0);
+            ctx.builder.build_store(file_ptr, filename).unwrap();
+            let row_ptr = ctx
+                .builder
+                .build_in_bounds_gep(exception, &[zero, int32.const_int(2, false)], "row_ptr")
+                .unwrap();
+            ctx.builder.build_store(row_ptr, int32.const_int(loc.row as u64, false)).unwrap();
+            let col_ptr = ctx
+                .builder
+                .build_in_bounds_gep(exception, &[zero, int32.const_int(3, false)], "col_ptr")
+                .unwrap();
+            ctx.builder.build_store(col_ptr, int32.const_int(loc.column as u64, false)).unwrap();
 
-        let current_fun = ctx.builder.get_insert_block().and_then(BasicBlock::get_parent).unwrap();
-        let fun_name = ctx.gen_string(generator, current_fun.get_name().to_str().unwrap());
-        exception.store_func(ctx, fun_name);
+            let current_fun = ctx.builder.get_insert_block().unwrap().get_parent().unwrap();
+            let fun_name = ctx.gen_string(generator, current_fun.get_name().to_str().unwrap());
+            let name_ptr = ctx
+                .builder
+                .build_in_bounds_gep(exception, &[zero, int32.const_int(4, false)], "name_ptr")
+                .unwrap();
+            ctx.builder.build_store(name_ptr, fun_name).unwrap();
+        }
 
         let raise = get_builtins(generator, ctx, "__nac3_raise");
         let exception = *exception;
-        ctx.build_call_or_invoke(raise, &[exception.as_abi_value(ctx).into()], "raise");
+        ctx.build_call_or_invoke(raise, &[exception], "raise");
     } else {
         let resume = get_builtins(generator, ctx, "__nac3_resume");
         ctx.build_call_or_invoke(resume, &[], "resume");
@@ -1836,8 +1860,6 @@ pub fn gen_stmt<G: CodeGenerator>(
                 } else {
                     return Ok(());
                 };
-                let exc = ExceptionType::get_instance(generator, ctx)
-                    .map_pointer_value(exc.into_pointer_value(), None);
                 gen_raise(generator, ctx, Some(&exc), stmt.location);
             } else {
                 gen_raise(generator, ctx, None, stmt.location);

nac3core/src/codegen/test.rs

@@ -17,6 +17,7 @@ use parking_lot::RwLock;
 
 use super::{
     concrete_type::ConcreteTypeStore,
+    tracert::TraceRuntimeConfig,
     types::{ndarray::NDArrayType, ListType, ProxyType, RangeType},
     CodeGenContext, CodeGenLLVMOptions, CodeGenTargetMachineOptions, CodeGenTask, CodeGenerator,
     DefaultCodeGenerator, WithCall, WorkerRegistry,
@@ -243,7 +244,13 @@ fn test_primitives() {
         opt_level: OptimizationLevel::Default,
         target: CodeGenTargetMachineOptions::from_host_triple(),
     };
-    let (registry, handles) = WorkerRegistry::create_workers(threads, top_level, &llvm_options, &f);
+    let (registry, handles) = WorkerRegistry::create_workers(
+        threads,
+        top_level,
+        &llvm_options,
+        &TraceRuntimeConfig::default(),
+        &f,
+    );
     registry.add_task(task);
     registry.wait_tasks_complete(handles);
 }
@@ -433,7 +440,13 @@ fn test_simple_call() {
         opt_level: OptimizationLevel::Default,
         target: CodeGenTargetMachineOptions::from_host_triple(),
     };
-    let (registry, handles) = WorkerRegistry::create_workers(threads, top_level, &llvm_options, &f);
+    let (registry, handles) = WorkerRegistry::create_workers(
+        threads,
+        top_level,
+        &llvm_options,
+        &TraceRuntimeConfig::default(),
+        &f,
+    );
     registry.add_task(task);
     registry.wait_tasks_complete(handles);
 }

nac3core/src/codegen/tracert/mod.rs

@@ -0,0 +1,110 @@
+use std::panic::Location;
+
+use inkwell::context::Context;
+use inkwell::memory_buffer::MemoryBuffer;
+use inkwell::module::Module;
+use inkwell::values::BasicValueEnum;
+use inkwell::AtomicOrdering;
+
+use crate::codegen::{extern_fns, CodeGenContext};
+
+#[derive(Clone, Default, Eq, PartialEq)]
+pub struct TraceRuntimeConfig {
+    pub enabled_tags: Vec<String>,
+}
+
+#[derive(Eq, Clone, PartialEq)]
+pub struct TraceRuntimeState {
+    config: TraceRuntimeConfig,
+    indent: usize,
+}
+
+impl TraceRuntimeState {
+    #[must_use]
+    pub fn create(config: TraceRuntimeConfig) -> TraceRuntimeState {
+        TraceRuntimeState { config, indent: 0 }
+    }
+}
+
+#[must_use]
+pub fn load_tracert<'ctx>(ctx: &'ctx Context, config: &TraceRuntimeConfig) -> Option<Module<'ctx>> {
+    if cfg!(feature = "tracing") && !config.enabled_tags.is_empty() {
+        let bitcode_buf = MemoryBuffer::create_from_memory_range(
+            include_bytes!(concat!(env!("OUT_DIR"), "/tracert.bc")),
+            "tracert_bitcode_buffer",
+        );
+        let module = Module::parse_bitcode_from_buffer(&bitcode_buf, ctx).unwrap();
+
+        return Some(module);
+    }
+
+    None
+}
+
+// TODO: Might need to redesign how trace logging should be done
+
+pub fn trace_log<'ctx>(
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    tag: &'static str,
+    format: &'static str,
+    args: &[BasicValueEnum<'ctx>],
+) {
+    if ctx.tracert_state.is_none() {
+        return;
+    }
+
+    // TODO: Add indentation
+    let str = format!("[TRACING] {tag} - {format}\n\0");
+    extern_fns::call_printf(ctx, &str, args);
+}
+
+#[track_caller]
+pub fn trace_log_with_location<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    tag: &'static str,
+    format: &str,
+    args: &[BasicValueEnum<'ctx>],
+) {
+    if ctx.tracert_state.is_none() {
+        return;
+    }
+
+    // TODO: Add indentation
+    let caller_loc = Location::caller();
+    let str = format!(
+        "[TRACING] {}:{}:{}: {tag} - {format}\n\0",
+        caller_loc.file(),
+        caller_loc.line(),
+        caller_loc.column()
+    );
+    extern_fns::call_printf(ctx, &str, args);
+}
+
+pub fn trace_push_level(ctx: &mut CodeGenContext<'_, '_>) {
+    let Some(tracert_state) = &mut ctx.tracert_state else {
+        return;
+    };
+
+    debug_assert!(tracert_state.indent < usize::MAX);
+    if tracert_state.indent < usize::MAX {
+        tracert_state.indent = tracert_state.indent.saturating_add(1);
+    }
+}
+
+pub fn trace_pop_level(ctx: &mut CodeGenContext<'_, '_>) {
+    let Some(tracert_state) = &mut ctx.tracert_state else {
+        return;
+    };
+
+    debug_assert!(tracert_state.indent > 0);
+    if tracert_state.indent > 0 {
+        tracert_state.indent = tracert_state.indent.saturating_sub(1);
+    }
+}
+
+#[inline]
+pub fn mfence(ctx: &mut CodeGenContext<'_, '_>) {
+    if ctx.tracert_state.is_some() {
+        ctx.builder.build_fence(AtomicOrdering::SequentiallyConsistent, 0, "").unwrap();
+    }
+}

nac3core/src/codegen/types/exception.rs

@@ -1,257 +0,0 @@
-use inkwell::{
-    context::{AsContextRef, Context},
-    types::{AnyTypeEnum, BasicType, BasicTypeEnum, IntType, PointerType, StructType},
-    values::{IntValue, PointerValue, StructValue},
-    AddressSpace,
-};
-use itertools::Itertools;
-
-use nac3core_derive::StructFields;
-
-use super::{
-    structure::{check_struct_type_matches_fields, StructField, StructFields, StructProxyType},
-    ProxyType,
-};
-use crate::{
-    codegen::{values::ExceptionValue, CodeGenContext, CodeGenerator},
-    typecheck::typedef::{Type, TypeEnum},
-};
-
-/// Proxy type for an `Exception` in LLVM.
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub struct ExceptionType<'ctx> {
-    ty: PointerType<'ctx>,
-    llvm_usize: IntType<'ctx>,
-}
-
-#[derive(PartialEq, Eq, Clone, Copy, StructFields)]
-pub struct ExceptionStructFields<'ctx> {
-    /// The ID of the exception name.
-    #[value_type(i32_type())]
-    pub name: StructField<'ctx, IntValue<'ctx>>,
-
-    /// The file where the exception originated from.
-    #[value_type(get_struct_type("str").unwrap())]
-    pub file: StructField<'ctx, StructValue<'ctx>>,
-
-    /// The line number where the exception originated from.
-    #[value_type(i32_type())]
-    pub line: StructField<'ctx, IntValue<'ctx>>,
-
-    /// The column number where the exception originated from.
-    #[value_type(i32_type())]
-    pub col: StructField<'ctx, IntValue<'ctx>>,
-
-    /// The function name where the exception originated from.
-    #[value_type(get_struct_type("str").unwrap())]
-    pub func: StructField<'ctx, StructValue<'ctx>>,
-
-    /// The exception message.
-    #[value_type(get_struct_type("str").unwrap())]
-    pub message: StructField<'ctx, StructValue<'ctx>>,
-
-    #[value_type(i64_type())]
-    pub param0: StructField<'ctx, IntValue<'ctx>>,
-
-    #[value_type(i64_type())]
-    pub param1: StructField<'ctx, IntValue<'ctx>>,
-
-    #[value_type(i64_type())]
-    pub param2: StructField<'ctx, IntValue<'ctx>>,
-}
-
-impl<'ctx> ExceptionType<'ctx> {
-    /// Returns an instance of [`StructFields`] containing all field accessors for this type.
-    #[must_use]
-    fn fields(
-        ctx: impl AsContextRef<'ctx>,
-        llvm_usize: IntType<'ctx>,
-    ) -> ExceptionStructFields<'ctx> {
-        ExceptionStructFields::new(ctx, llvm_usize)
-    }
-
-    /// Creates an LLVM type corresponding to the expected structure of an `Exception`.
-    #[must_use]
-    fn llvm_type(ctx: &'ctx Context, llvm_usize: IntType<'ctx>) -> PointerType<'ctx> {
-        assert!(ctx.get_struct_type("str").is_some());
-
-        let field_tys =
-            Self::fields(ctx, llvm_usize).into_iter().map(|field| field.1).collect_vec();
-
-        ctx.struct_type(&field_tys, false).ptr_type(AddressSpace::default())
-    }
-
-    fn new_impl(ctx: &'ctx Context, llvm_usize: IntType<'ctx>) -> Self {
-        let llvm_str = Self::llvm_type(ctx, llvm_usize);
-
-        Self { ty: llvm_str, llvm_usize }
-    }
-
-    /// Creates an instance of [`ExceptionType`].
-    #[must_use]
-    pub fn new(ctx: &CodeGenContext<'ctx, '_>) -> Self {
-        Self::new_impl(ctx.ctx, ctx.get_size_type())
-    }
-
-    /// Creates an instance of [`ExceptionType`].
-    #[must_use]
-    pub fn new_with_generator<G: CodeGenerator + ?Sized>(
-        generator: &G,
-        ctx: &'ctx Context,
-    ) -> Self {
-        Self::new_impl(ctx, generator.get_size_type(ctx))
-    }
-
-    /// Creates an [`ExceptionType`] from a [unifier type][Type].
-    #[must_use]
-    pub fn from_unifier_type(ctx: &mut CodeGenContext<'ctx, '_>, ty: Type) -> Self {
-        // Check unifier type
-        assert!(
-            matches!(&*ctx.unifier.get_ty_immutable(ty), TypeEnum::TObj { obj_id, .. } if *obj_id == ctx.primitives.exception.obj_id(&ctx.unifier).unwrap())
-        );
-
-        Self::new_impl(ctx.ctx, ctx.get_size_type())
-    }
-
-    /// Creates an [`ExceptionType`] from a [`StructType`] representing an `Exception`.
-    #[must_use]
-    pub fn from_struct_type(ty: StructType<'ctx>, llvm_usize: IntType<'ctx>) -> Self {
-        Self::from_pointer_type(ty.ptr_type(AddressSpace::default()), llvm_usize)
-    }
-
-    /// Creates an [`ExceptionType`] from a [`PointerType`] representing an `Exception`.
-    #[must_use]
-    pub fn from_pointer_type(ptr_ty: PointerType<'ctx>, llvm_usize: IntType<'ctx>) -> Self {
-        debug_assert!(Self::has_same_repr(ptr_ty, llvm_usize).is_ok());
-
-        Self { ty: ptr_ty, llvm_usize }
-    }
-
-    /// Returns an instance of [`ExceptionType`] by obtaining the LLVM representation of the builtin
-    /// `Exception` type.
-    #[must_use]
-    pub fn get_instance<G: CodeGenerator + ?Sized>(
-        generator: &mut G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-    ) -> Self {
-        Self::from_pointer_type(
-            ctx.get_llvm_type(generator, ctx.primitives.exception).into_pointer_type(),
-            ctx.get_size_type(),
-        )
-    }
-
-    /// Allocates an instance of [`ExceptionValue`] as if by calling `alloca` on the base type.
-    ///
-    /// See [`ProxyType::raw_alloca`].
-    #[must_use]
-    pub fn alloca(
-        &self,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        name: Option<&'ctx str>,
-    ) -> <Self as ProxyType<'ctx>>::Value {
-        <Self as ProxyType<'ctx>>::Value::from_pointer_value(
-            self.raw_alloca(ctx, name),
-            self.llvm_usize,
-            name,
-        )
-    }
-
-    /// Allocates an instance of [`ExceptionValue`] as if by calling `alloca` on the base type.
-    ///
-    /// See [`ProxyType::raw_alloca_var`].
-    #[must_use]
-    pub fn alloca_var<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &mut G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        name: Option<&'ctx str>,
-    ) -> <Self as ProxyType<'ctx>>::Value {
-        <Self as ProxyType<'ctx>>::Value::from_pointer_value(
-            self.raw_alloca_var(generator, ctx, name),
-            self.llvm_usize,
-            name,
-        )
-    }
-
-    /// Converts an existing value into a [`ExceptionValue`].
-    #[must_use]
-    pub fn map_struct_value<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &mut G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        value: StructValue<'ctx>,
-        name: Option<&'ctx str>,
-    ) -> <Self as ProxyType<'ctx>>::Value {
-        <Self as ProxyType<'ctx>>::Value::from_struct_value(
-            generator,
-            ctx,
-            value,
-            self.llvm_usize,
-            name,
-        )
-    }
-
-    /// Converts an existing value into a [`ExceptionValue`].
-    #[must_use]
-    pub fn map_pointer_value(
-        &self,
-        value: PointerValue<'ctx>,
-        name: Option<&'ctx str>,
-    ) -> <Self as ProxyType<'ctx>>::Value {
-        <Self as ProxyType<'ctx>>::Value::from_pointer_value(value, self.llvm_usize, name)
-    }
-}
-
-impl<'ctx> ProxyType<'ctx> for ExceptionType<'ctx> {
-    type ABI = PointerType<'ctx>;
-    type Base = PointerType<'ctx>;
-    type Value = ExceptionValue<'ctx>;
-
-    fn is_representable(
-        llvm_ty: impl BasicType<'ctx>,
-        llvm_usize: IntType<'ctx>,
-    ) -> Result<(), String> {
-        if let BasicTypeEnum::PointerType(ty) = llvm_ty.as_basic_type_enum() {
-            Self::has_same_repr(ty, llvm_usize)
-        } else {
-            Err(format!("Expected pointer type, got {llvm_ty:?}"))
-        }
-    }
-
-    fn has_same_repr(ty: Self::Base, llvm_usize: IntType<'ctx>) -> Result<(), String> {
-        let ctx = ty.get_context();
-
-        let llvm_ty = ty.get_element_type();
-        let AnyTypeEnum::StructType(llvm_ty) = llvm_ty else {
-            return Err(format!("Expected struct type for `list` type, got {llvm_ty}"));
-        };
-
-        check_struct_type_matches_fields(Self::fields(ctx, llvm_usize), llvm_ty, "exception", &[])
-    }
-
-    fn alloca_type(&self) -> impl BasicType<'ctx> {
-        self.as_abi_type().get_element_type().into_struct_type()
-    }
-
-    fn as_base_type(&self) -> Self::Base {
-        self.ty
-    }
-
-    fn as_abi_type(&self) -> Self::ABI {
-        self.as_base_type()
-    }
-}
-
-impl<'ctx> StructProxyType<'ctx> for ExceptionType<'ctx> {
-    type StructFields = ExceptionStructFields<'ctx>;
-
-    fn get_fields(&self) -> Self::StructFields {
-        Self::fields(self.ty.get_context(), self.llvm_usize)
-    }
-}
-
-impl<'ctx> From<ExceptionType<'ctx>> for PointerType<'ctx> {
-    fn from(value: ExceptionType<'ctx>) -> Self {
-        value.as_base_type()
-    }
-}

nac3core/src/codegen/types/mod.rs

@@ -25,19 +25,13 @@ use super::{
     values::{ArraySliceValue, ProxyValue},
     {CodeGenContext, CodeGenerator},
 };
-pub use exception::*;
 pub use list::*;
-pub use option::*;
 pub use range::*;
-pub use string::*;
 pub use tuple::*;
 
-mod exception;
 mod list;
 pub mod ndarray;
-mod option;
 mod range;
-mod string;
 pub mod structure;
 mod tuple;
 pub mod utils;

nac3core/src/codegen/types/option.rs

@@ -1,188 +0,0 @@
-use inkwell::{
-    context::Context,
-    types::{BasicType, BasicTypeEnum, IntType, PointerType},
-    values::{BasicValue, BasicValueEnum, PointerValue},
-    AddressSpace,
-};
-
-use super::ProxyType;
-use crate::{
-    codegen::{values::OptionValue, CodeGenContext, CodeGenerator},
-    typecheck::typedef::{iter_type_vars, Type, TypeEnum},
-};
-
-/// Proxy type for an `Option` type in LLVM.
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub struct OptionType<'ctx> {
-    ty: PointerType<'ctx>,
-    llvm_usize: IntType<'ctx>,
-}
-
-impl<'ctx> OptionType<'ctx> {
-    /// Creates an LLVM type corresponding to the expected structure of an `Option`.
-    #[must_use]
-    fn llvm_type(element_type: &impl BasicType<'ctx>) -> PointerType<'ctx> {
-        element_type.ptr_type(AddressSpace::default())
-    }
-
-    fn new_impl(element_type: &impl BasicType<'ctx>, llvm_usize: IntType<'ctx>) -> Self {
-        let llvm_option = Self::llvm_type(element_type);
-
-        Self { ty: llvm_option, llvm_usize }
-    }
-
-    /// Creates an instance of [`OptionType`].
-    #[must_use]
-    pub fn new(ctx: &CodeGenContext<'ctx, '_>, element_type: &impl BasicType<'ctx>) -> Self {
-        Self::new_impl(element_type, ctx.get_size_type())
-    }
-
-    /// Creates an instance of [`OptionType`].
-    #[must_use]
-    pub fn new_with_generator<G: CodeGenerator + ?Sized>(
-        generator: &G,
-        ctx: &'ctx Context,
-        element_type: &impl BasicType<'ctx>,
-    ) -> Self {
-        Self::new_impl(element_type, generator.get_size_type(ctx))
-    }
-
-    /// Creates an [`OptionType`] from a [unifier type][Type].
-    #[must_use]
-    pub fn from_unifier_type<G: CodeGenerator + ?Sized>(
-        generator: &G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        ty: Type,
-    ) -> Self {
-        // Check unifier type and extract `element_type`
-        let elem_type = match &*ctx.unifier.get_ty_immutable(ty) {
-            TypeEnum::TObj { obj_id, params, .. }
-                if *obj_id == ctx.primitives.option.obj_id(&ctx.unifier).unwrap() =>
-            {
-                iter_type_vars(params).next().unwrap().ty
-            }
-
-            _ => panic!("Expected `option` type, but got {}", ctx.unifier.stringify(ty)),
-        };
-
-        let llvm_usize = ctx.get_size_type();
-        let llvm_elem_type = ctx.get_llvm_type(generator, elem_type);
-
-        Self::new_impl(&llvm_elem_type, llvm_usize)
-    }
-
-    /// Creates an [`OptionType`] from a [`PointerType`].
-    #[must_use]
-    pub fn from_pointer_type(ptr_ty: PointerType<'ctx>, llvm_usize: IntType<'ctx>) -> Self {
-        debug_assert!(Self::has_same_repr(ptr_ty, llvm_usize).is_ok());
-
-        Self { ty: ptr_ty, llvm_usize }
-    }
-
-    /// Returns the element type of this `Option` type.
-    #[must_use]
-    pub fn element_type(&self) -> BasicTypeEnum<'ctx> {
-        BasicTypeEnum::try_from(self.ty.get_element_type()).unwrap()
-    }
-
-    /// Allocates an [`OptionValue`] on the stack.
-    ///
-    /// The returned value will be `Some(v)` if [`value` contains a value][Option::is_some],
-    /// otherwise `none` will be returned.
-    #[must_use]
-    pub fn construct<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &mut G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        value: Option<BasicValueEnum<'ctx>>,
-        name: Option<&'ctx str>,
-    ) -> <Self as ProxyType<'ctx>>::Value {
-        let ptr = if let Some(v) = value {
-            let pvar = self.raw_alloca_var(generator, ctx, name);
-            ctx.builder.build_store(pvar, v).unwrap();
-            pvar
-        } else {
-            self.ty.const_null()
-        };
-
-        self.map_pointer_value(ptr, name)
-    }
-    /// Allocates an [`OptionValue`] on the stack.
-    ///
-    /// The returned value will always be `none`.
-    #[must_use]
-    pub fn construct_empty<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &mut G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        name: Option<&'ctx str>,
-    ) -> <Self as ProxyType<'ctx>>::Value {
-        self.construct(generator, ctx, None, name)
-    }
-
-    /// Allocates an [`OptionValue`] on the stack.
-    ///
-    /// The returned value will be set to `Some(value)`.
-    #[must_use]
-    pub fn construct_some_value<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &mut G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        value: &impl BasicValue<'ctx>,
-        name: Option<&'ctx str>,
-    ) -> <Self as ProxyType<'ctx>>::Value {
-        self.construct(generator, ctx, Some(value.as_basic_value_enum()), name)
-    }
-
-    /// Converts an existing value into a [`OptionValue`].
-    #[must_use]
-    pub fn map_pointer_value(
-        &self,
-        value: PointerValue<'ctx>,
-        name: Option<&'ctx str>,
-    ) -> <Self as ProxyType<'ctx>>::Value {
-        <Self as ProxyType<'ctx>>::Value::from_pointer_value(value, self.llvm_usize, name)
-    }
-}
-
-impl<'ctx> ProxyType<'ctx> for OptionType<'ctx> {
-    type ABI = PointerType<'ctx>;
-    type Base = PointerType<'ctx>;
-    type Value = OptionValue<'ctx>;
-
-    fn is_representable(
-        llvm_ty: impl BasicType<'ctx>,
-        llvm_usize: IntType<'ctx>,
-    ) -> Result<(), String> {
-        if let BasicTypeEnum::PointerType(ty) = llvm_ty.as_basic_type_enum() {
-            Self::has_same_repr(ty, llvm_usize)
-        } else {
-            Err(format!("Expected pointer type, got {llvm_ty:?}"))
-        }
-    }
-
-    fn has_same_repr(ty: Self::Base, _: IntType<'ctx>) -> Result<(), String> {
-        BasicTypeEnum::try_from(ty.get_element_type())
-            .map_err(|()| format!("Expected `ty` to be a BasicTypeEnum, got {ty}"))?;
-
-        Ok(())
-    }
-
-    fn alloca_type(&self) -> impl BasicType<'ctx> {
-        self.element_type()
-    }
-
-    fn as_base_type(&self) -> Self::Base {
-        self.ty
-    }
-
-    fn as_abi_type(&self) -> Self::ABI {
-        self.as_base_type()
-    }
-}
-
-impl<'ctx> From<OptionType<'ctx>> for PointerType<'ctx> {
-    fn from(value: OptionType<'ctx>) -> Self {
-        value.as_base_type()
-    }
-}

nac3core/src/codegen/types/string.rs

@@ -1,177 +0,0 @@
-use inkwell::{
-    context::Context,
-    types::{BasicType, BasicTypeEnum, IntType, PointerType, StructType},
-    values::{GlobalValue, IntValue, PointerValue, StructValue},
-    AddressSpace,
-};
-use itertools::Itertools;
-
-use nac3core_derive::StructFields;
-
-use super::{
-    structure::{check_struct_type_matches_fields, StructField, StructFields},
-    ProxyType,
-};
-use crate::codegen::{values::StringValue, CodeGenContext, CodeGenerator};
-
-/// Proxy type for a `str` type in LLVM.
-#[derive(Debug, PartialEq, Eq, Clone, Copy)]
-pub struct StringType<'ctx> {
-    ty: StructType<'ctx>,
-    llvm_usize: IntType<'ctx>,
-}
-
-#[derive(PartialEq, Eq, Clone, Copy, StructFields)]
-pub struct StringStructFields<'ctx> {
-    /// Pointer to the first character of the string.
-    #[value_type(i8_type().ptr_type(AddressSpace::default()))]
-    pub ptr: StructField<'ctx, PointerValue<'ctx>>,
-
-    /// Length of the string.
-    #[value_type(usize)]
-    pub len: StructField<'ctx, IntValue<'ctx>>,
-}
-
-impl<'ctx> StringType<'ctx> {
-    /// Returns an instance of [`StructFields`] containing all field accessors for this type.
-    #[must_use]
-    fn fields(llvm_usize: IntType<'ctx>) -> StringStructFields<'ctx> {
-        StringStructFields::new(llvm_usize.get_context(), llvm_usize)
-    }
-
-    /// Creates an LLVM type corresponding to the expected structure of a `str`.
-    #[must_use]
-    fn llvm_type(ctx: &'ctx Context, llvm_usize: IntType<'ctx>) -> StructType<'ctx> {
-        const NAME: &str = "str";
-
-        if let Some(t) = ctx.get_struct_type(NAME) {
-            t
-        } else {
-            let str_ty = ctx.opaque_struct_type(NAME);
-            let field_tys = Self::fields(llvm_usize).into_iter().map(|field| field.1).collect_vec();
-            str_ty.set_body(&field_tys, false);
-            str_ty
-        }
-    }
-
-    fn new_impl(ctx: &'ctx Context, llvm_usize: IntType<'ctx>) -> Self {
-        let llvm_str = Self::llvm_type(ctx, llvm_usize);
-
-        Self { ty: llvm_str, llvm_usize }
-    }
-
-    /// Creates an instance of [`StringType`].
-    #[must_use]
-    pub fn new(ctx: &CodeGenContext<'ctx, '_>) -> Self {
-        Self::new_impl(ctx.ctx, ctx.get_size_type())
-    }
-
-    /// Creates an instance of [`StringType`].
-    #[must_use]
-    pub fn new_with_generator<G: CodeGenerator + ?Sized>(
-        generator: &G,
-        ctx: &'ctx Context,
-    ) -> Self {
-        Self::new_impl(ctx, generator.get_size_type(ctx))
-    }
-
-    /// Creates an [`StringType`] from a [`StructType`] representing a `str`.
-    #[must_use]
-    pub fn from_struct_type(ty: StructType<'ctx>, llvm_usize: IntType<'ctx>) -> Self {
-        debug_assert!(Self::has_same_repr(ty, llvm_usize).is_ok());
-
-        Self { ty, llvm_usize }
-    }
-
-    /// Creates an [`StringType`] from a [`PointerType`] representing a `str`.
-    #[must_use]
-    pub fn from_pointer_type(ptr_ty: PointerType<'ctx>, llvm_usize: IntType<'ctx>) -> Self {
-        Self::from_struct_type(ptr_ty.get_element_type().into_struct_type(), llvm_usize)
-    }
-
-    /// Returns the fields present in this [`StringType`].
-    #[must_use]
-    pub fn get_fields(&self) -> StringStructFields<'ctx> {
-        Self::fields(self.llvm_usize)
-    }
-
-    /// Constructs a global constant string.
-    #[must_use]
-    pub fn construct_constant(
-        &self,
-        ctx: &CodeGenContext<'ctx, '_>,
-        v: &str,
-        name: Option<&'ctx str>,
-    ) -> StringValue<'ctx> {
-        let str_ptr = ctx
-            .builder
-            .build_global_string_ptr(v, "const")
-            .map(GlobalValue::as_pointer_value)
-            .unwrap();
-        let size = ctx.get_size_type().const_int(v.len() as u64, false);
-        self.map_struct_value(
-            self.as_abi_type().const_named_struct(&[str_ptr.into(), size.into()]),
-            name,
-        )
-    }
-
-    /// Converts an existing value into a [`StringValue`].
-    #[must_use]
-    pub fn map_struct_value(
-        &self,
-        value: StructValue<'ctx>,
-        name: Option<&'ctx str>,
-    ) -> <Self as ProxyType<'ctx>>::Value {
-        <Self as ProxyType<'ctx>>::Value::from_struct_value(value, self.llvm_usize, name)
-    }
-
-    /// Converts an existing value into a [`StringValue`].
-    #[must_use]
-    pub fn map_pointer_value(
-        &self,
-        ctx: &CodeGenContext<'ctx, '_>,
-        value: PointerValue<'ctx>,
-        name: Option<&'ctx str>,
-    ) -> <Self as ProxyType<'ctx>>::Value {
-        <Self as ProxyType<'ctx>>::Value::from_pointer_value(ctx, value, self.llvm_usize, name)
-    }
-}
-
-impl<'ctx> ProxyType<'ctx> for StringType<'ctx> {
-    type ABI = StructType<'ctx>;
-    type Base = StructType<'ctx>;
-    type Value = StringValue<'ctx>;
-
-    fn is_representable(
-        llvm_ty: impl BasicType<'ctx>,
-        llvm_usize: IntType<'ctx>,
-    ) -> Result<(), String> {
-        if let BasicTypeEnum::StructType(ty) = llvm_ty.as_basic_type_enum() {
-            Self::has_same_repr(ty, llvm_usize)
-        } else {
-            Err(format!("Expected structure type, got {llvm_ty:?}"))
-        }
-    }
-
-    fn has_same_repr(ty: Self::Base, llvm_usize: IntType<'ctx>) -> Result<(), String> {
-        check_struct_type_matches_fields(Self::fields(llvm_usize), ty, "str", &[])
-    }
-
-    fn alloca_type(&self) -> impl BasicType<'ctx> {
-        self.as_abi_type()
-    }
-
-    fn as_base_type(&self) -> Self::Base {
-        self.ty
-    }
-
-    fn as_abi_type(&self) -> Self::ABI {
-        self.as_base_type()
-    }
-}
-
-impl<'ctx> From<StringType<'ctx>> for StructType<'ctx> {
-    fn from(value: StringType<'ctx>) -> Self {
-        value.as_base_type()
-    }
-}

nac3core/src/codegen/types/tuple.rs

@@ -115,8 +115,15 @@ impl<'ctx> TupleType<'ctx> {
 
     /// Constructs a [`TupleValue`] from this type by zero-initializing the tuple value.
     #[must_use]
-    pub fn construct(&self, name: Option<&'ctx str>) -> <Self as ProxyType<'ctx>>::Value {
-        self.map_struct_value(self.as_abi_type().const_zero(), name)
+    pub fn construct(
+        &self,
+        ctx: &CodeGenContext<'ctx, '_>,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        self.map_struct_value(
+            Self::llvm_type(ctx.ctx, &self.ty.get_field_types()).const_zero(),
+            name,
+        )
     }
 
     /// Constructs a [`TupleValue`] from `objects`. The resulting tuple preserves the order of
@@ -136,9 +143,9 @@ impl<'ctx> TupleType<'ctx> {
             .enumerate()
             .all(|(i, v)| { v.get_type() == unsafe { self.type_at_index_unchecked(i as u32) } }));
 
-        let mut value = self.construct(name);
+        let mut value = self.construct(ctx, name);
         for (i, val) in values.into_iter().enumerate() {
-            value.insert_element(ctx, i as u32, val);
+            value.store_element(ctx, i as u32, val);
         }
 
         value

nac3core/src/codegen/values/exception.rs

@@ -1,188 +0,0 @@
-use inkwell::{
-    types::IntType,
-    values::{IntValue, PointerValue, StructValue},
-};
-use itertools::Itertools;
-
-use nac3parser::ast::Location;
-
-use super::{structure::StructProxyValue, ProxyValue, StringValue};
-use crate::codegen::{
-    types::{
-        structure::{StructField, StructProxyType},
-        ExceptionType,
-    },
-    CodeGenContext, CodeGenerator,
-};
-
-/// Proxy type for accessing an `Exception` value in LLVM.
-#[derive(Copy, Clone)]
-pub struct ExceptionValue<'ctx> {
-    value: PointerValue<'ctx>,
-    llvm_usize: IntType<'ctx>,
-    name: Option<&'ctx str>,
-}
-
-impl<'ctx> ExceptionValue<'ctx> {
-    /// Creates an [`ExceptionValue`] from a [`StructValue`].
-    #[must_use]
-    pub fn from_struct_value<G: CodeGenerator + ?Sized>(
-        generator: &mut G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        val: StructValue<'ctx>,
-        llvm_usize: IntType<'ctx>,
-        name: Option<&'ctx str>,
-    ) -> Self {
-        let pval = generator
-            .gen_var_alloc(
-                ctx,
-                val.get_type().into(),
-                name.map(|name| format!("{name}.addr")).as_deref(),
-            )
-            .unwrap();
-        ctx.builder.build_store(pval, val).unwrap();
-        Self::from_pointer_value(pval, llvm_usize, name)
-    }
-
-    /// Creates an [`ExceptionValue`] from a [`PointerValue`].
-    #[must_use]
-    pub fn from_pointer_value(
-        ptr: PointerValue<'ctx>,
-        llvm_usize: IntType<'ctx>,
-        name: Option<&'ctx str>,
-    ) -> Self {
-        debug_assert!(Self::is_instance(ptr, llvm_usize).is_ok());
-
-        Self { value: ptr, llvm_usize, name }
-    }
-
-    fn name_field(&self) -> StructField<'ctx, IntValue<'ctx>> {
-        self.get_type().get_fields().name
-    }
-
-    /// Stores the ID of the exception name into this instance.
-    pub fn store_name(&self, ctx: &CodeGenContext<'ctx, '_>, name: IntValue<'ctx>) {
-        debug_assert_eq!(name.get_type(), ctx.ctx.i32_type());
-
-        self.name_field().store(ctx, self.value, name, self.name);
-    }
-
-    fn file_field(&self) -> StructField<'ctx, StructValue<'ctx>> {
-        self.get_type().get_fields().file
-    }
-
-    /// Stores the file name of the exception source into this instance.
-    pub fn store_file(&self, ctx: &CodeGenContext<'ctx, '_>, file: StructValue<'ctx>) {
-        debug_assert!(StringValue::is_instance(file, self.llvm_usize).is_ok());
-
-        self.file_field().store(ctx, self.value, file, self.name);
-    }
-
-    fn line_field(&self) -> StructField<'ctx, IntValue<'ctx>> {
-        self.get_type().get_fields().line
-    }
-
-    fn col_field(&self) -> StructField<'ctx, IntValue<'ctx>> {
-        self.get_type().get_fields().col
-    }
-
-    /// Stores the [location][Location] of the exception source into this instance.
-    pub fn store_location<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &mut G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        location: Location,
-    ) {
-        let llvm_i32 = ctx.ctx.i32_type();
-
-        let filename = ctx.gen_string(generator, location.file.0);
-        self.store_file(ctx, filename);
-
-        self.line_field().store(
-            ctx,
-            self.value,
-            llvm_i32.const_int(location.row as u64, false),
-            self.name,
-        );
-        self.col_field().store(
-            ctx,
-            self.value,
-            llvm_i32.const_int(location.column as u64, false),
-            self.name,
-        );
-    }
-
-    fn func_field(&self) -> StructField<'ctx, StructValue<'ctx>> {
-        self.get_type().get_fields().func
-    }
-
-    /// Stores the function name of the exception source into this instance.
-    pub fn store_func(&self, ctx: &CodeGenContext<'ctx, '_>, func: StructValue<'ctx>) {
-        debug_assert!(StringValue::is_instance(func, self.llvm_usize).is_ok());
-
-        self.func_field().store(ctx, self.value, func, self.name);
-    }
-
-    fn message_field(&self) -> StructField<'ctx, StructValue<'ctx>> {
-        self.get_type().get_fields().message
-    }
-
-    /// Stores the exception message into this instance.
-    pub fn store_message(&self, ctx: &CodeGenContext<'ctx, '_>, message: StructValue<'ctx>) {
-        debug_assert!(StringValue::is_instance(message, self.llvm_usize).is_ok());
-
-        self.message_field().store(ctx, self.value, message, self.name);
-    }
-
-    fn param0_field(&self) -> StructField<'ctx, IntValue<'ctx>> {
-        self.get_type().get_fields().param0
-    }
-
-    fn param1_field(&self) -> StructField<'ctx, IntValue<'ctx>> {
-        self.get_type().get_fields().param1
-    }
-
-    fn param2_field(&self) -> StructField<'ctx, IntValue<'ctx>> {
-        self.get_type().get_fields().param2
-    }
-
-    /// Stores the parameters of the exception into this instance.
-    ///
-    /// If the parameter does not exist, pass `i64 0` in the parameter slot.
-    pub fn store_params(&self, ctx: &CodeGenContext<'ctx, '_>, params: &[IntValue<'ctx>; 3]) {
-        debug_assert!(params.iter().all(|p| p.get_type() == ctx.ctx.i64_type()));
-
-        [self.param0_field(), self.param1_field(), self.param2_field()]
-            .into_iter()
-            .zip_eq(params)
-            .for_each(|(field, param)| {
-                field.store(ctx, self.value, *param, self.name);
-            });
-    }
-}
-
-impl<'ctx> ProxyValue<'ctx> for ExceptionValue<'ctx> {
-    type ABI = PointerValue<'ctx>;
-    type Base = PointerValue<'ctx>;
-    type Type = ExceptionType<'ctx>;
-
-    fn get_type(&self) -> Self::Type {
-        Self::Type::from_pointer_type(self.value.get_type(), self.llvm_usize)
-    }
-
-    fn as_base_value(&self) -> Self::Base {
-        self.value
-    }
-
-    fn as_abi_value(&self, _: &CodeGenContext<'ctx, '_>) -> Self::ABI {
-        self.as_base_value()
-    }
-}
-
-impl<'ctx> StructProxyValue<'ctx> for ExceptionValue<'ctx> {}
-
-impl<'ctx> From<ExceptionValue<'ctx>> for PointerValue<'ctx> {
-    fn from(value: ExceptionValue<'ctx>) -> Self {
-        value.as_base_value()
-    }
-}

nac3core/src/codegen/values/mod.rs

@@ -2,20 +2,14 @@ use inkwell::{types::IntType, values::BasicValue};
 
 use super::{types::ProxyType, CodeGenContext};
 pub use array::*;
-pub use exception::*;
 pub use list::*;
-pub use option::*;
 pub use range::*;
-pub use string::*;
 pub use tuple::*;
 
 mod array;
-mod exception;
 mod list;
 pub mod ndarray;
-mod option;
 mod range;
-mod string;
 pub mod structure;
 mod tuple;
 pub mod utils;

nac3core/src/codegen/values/ndarray/matmul.rs

@@ -213,7 +213,9 @@ fn matmul_at_least_2d<'ctx, G: CodeGenerator>(
                     Binop::normal(Operator::Mult),
                     (&Some(rhs_dtype), b_kj),
                     ctx.current_loc,
-                )?;
+                )?
+                .unwrap()
+                .to_basic_value_enum(ctx, generator, dst_dtype)?;
 
                 // dst_[...]ij += x
                 let dst_ij = ctx.builder.build_load(pdst_ij, "").unwrap();
@@ -224,7 +226,9 @@ fn matmul_at_least_2d<'ctx, G: CodeGenerator>(
                     Binop::normal(Operator::Add),
                     (&Some(dst_dtype), x),
                     ctx.current_loc,
-                )?;
+                )?
+                .unwrap()
+                .to_basic_value_enum(ctx, generator, dst_dtype)?;
                 ctx.builder.build_store(pdst_ij, dst_ij).unwrap();
 
                 Ok(())

nac3core/src/codegen/values/ndarray/shape.rs

@@ -106,7 +106,7 @@ pub fn parse_numpy_int_sequence<'ctx, G: CodeGenerator + ?Sized>(
 
             for i in 0..input_seq.get_type().num_elements() {
                 // Get the i-th element off of the tuple and load it into `result`.
-                let int = input_seq.extract_element(ctx, i).into_int_value();
+                let int = input_seq.load_element(ctx, i).into_int_value();
                 let int = ctx.builder.build_int_s_extend_or_bit_cast(int, llvm_usize, "").unwrap();
 
                 unsafe {

nac3core/src/codegen/values/option.rs

@@ -1,75 +0,0 @@
-use inkwell::{
-    types::IntType,
-    values::{BasicValueEnum, IntValue, PointerValue},
-};
-
-use super::ProxyValue;
-use crate::codegen::{types::OptionType, CodeGenContext};
-
-/// Proxy type for accessing a `Option` value in LLVM.
-#[derive(Copy, Clone)]
-pub struct OptionValue<'ctx> {
-    value: PointerValue<'ctx>,
-    llvm_usize: IntType<'ctx>,
-    name: Option<&'ctx str>,
-}
-
-impl<'ctx> OptionValue<'ctx> {
-    /// Creates an [`OptionValue`] from a [`PointerValue`].
-    #[must_use]
-    pub fn from_pointer_value(
-        ptr: PointerValue<'ctx>,
-        llvm_usize: IntType<'ctx>,
-        name: Option<&'ctx str>,
-    ) -> Self {
-        debug_assert!(Self::is_instance(ptr, llvm_usize).is_ok());
-
-        Self { value: ptr, llvm_usize, name }
-    }
-
-    /// Returns an `i1` indicating if this `Option` instance does not hold a value.
-    #[must_use]
-    pub fn is_none(&self, ctx: &CodeGenContext<'ctx, '_>) -> IntValue<'ctx> {
-        ctx.builder.build_is_null(self.value, "").unwrap()
-    }
-
-    /// Returns an `i1` indicating if this `Option` instance contains a value.
-    #[must_use]
-    pub fn is_some(&self, ctx: &CodeGenContext<'ctx, '_>) -> IntValue<'ctx> {
-        ctx.builder.build_is_not_null(self.value, "").unwrap()
-    }
-
-    /// Loads the value present in this `Option` instance.
-    ///
-    /// # Safety
-    ///
-    /// The caller must ensure that this `option` value [contains a value][Self::is_some].
-    #[must_use]
-    pub unsafe fn load(&self, ctx: &CodeGenContext<'ctx, '_>) -> BasicValueEnum<'ctx> {
-        ctx.builder.build_load(self.value, "").unwrap()
-    }
-}
-
-impl<'ctx> ProxyValue<'ctx> for OptionValue<'ctx> {
-    type ABI = PointerValue<'ctx>;
-    type Base = PointerValue<'ctx>;
-    type Type = OptionType<'ctx>;
-
-    fn get_type(&self) -> Self::Type {
-        Self::Type::from_pointer_type(self.value.get_type(), self.llvm_usize)
-    }
-
-    fn as_base_value(&self) -> Self::Base {
-        self.value
-    }
-
-    fn as_abi_value(&self, _: &CodeGenContext<'ctx, '_>) -> Self::ABI {
-        self.as_base_value()
-    }
-}
-
-impl<'ctx> From<OptionValue<'ctx>> for PointerValue<'ctx> {
-    fn from(value: OptionValue<'ctx>) -> Self {
-        value.as_base_value()
-    }
-}

nac3core/src/codegen/values/string.rs

@@ -1,87 +0,0 @@
-use inkwell::{
-    types::IntType,
-    values::{BasicValueEnum, IntValue, PointerValue, StructValue},
-};
-
-use crate::codegen::{
-    types::{structure::StructField, StringType},
-    values::ProxyValue,
-    CodeGenContext,
-};
-
-/// Proxy type for accessing a `str` value in LLVM.
-#[derive(Copy, Clone)]
-pub struct StringValue<'ctx> {
-    value: StructValue<'ctx>,
-    llvm_usize: IntType<'ctx>,
-    name: Option<&'ctx str>,
-}
-
-impl<'ctx> StringValue<'ctx> {
-    /// Creates an [`StringValue`] from a [`StructValue`].
-    #[must_use]
-    pub fn from_struct_value(
-        val: StructValue<'ctx>,
-        llvm_usize: IntType<'ctx>,
-        name: Option<&'ctx str>,
-    ) -> Self {
-        debug_assert!(Self::is_instance(val, llvm_usize).is_ok());
-
-        Self { value: val, llvm_usize, name }
-    }
-
-    /// Creates an [`StringValue`] from a [`PointerValue`].
-    #[must_use]
-    pub fn from_pointer_value(
-        ctx: &CodeGenContext<'ctx, '_>,
-        ptr: PointerValue<'ctx>,
-        llvm_usize: IntType<'ctx>,
-        name: Option<&'ctx str>,
-    ) -> Self {
-        let val = ctx.builder.build_load(ptr, "").map(BasicValueEnum::into_struct_value).unwrap();
-
-        Self::from_struct_value(val, llvm_usize, name)
-    }
-
-    fn ptr_field(&self) -> StructField<'ctx, PointerValue<'ctx>> {
-        self.get_type().get_fields().ptr
-    }
-
-    /// Returns the pointer to the beginning of the string.
-    pub fn extract_ptr(&self, ctx: &CodeGenContext<'ctx, '_>) -> PointerValue<'ctx> {
-        self.ptr_field().extract_value(ctx, self.value)
-    }
-
-    fn len_field(&self) -> StructField<'ctx, IntValue<'ctx>> {
-        self.get_type().get_fields().len
-    }
-
-    /// Returns the length of the string.
-    pub fn extract_len(&self, ctx: &CodeGenContext<'ctx, '_>) -> IntValue<'ctx> {
-        self.len_field().extract_value(ctx, self.value)
-    }
-}
-
-impl<'ctx> ProxyValue<'ctx> for StringValue<'ctx> {
-    type ABI = StructValue<'ctx>;
-    type Base = StructValue<'ctx>;
-    type Type = StringType<'ctx>;
-
-    fn get_type(&self) -> Self::Type {
-        Self::Type::from_struct_type(self.value.get_type(), self.llvm_usize)
-    }
-
-    fn as_base_value(&self) -> Self::Base {
-        self.value
-    }
-
-    fn as_abi_value(&self, _: &CodeGenContext<'ctx, '_>) -> Self::ABI {
-        self.as_base_value()
-    }
-}
-
-impl<'ctx> From<StringValue<'ctx>> for StructValue<'ctx> {
-    fn from(value: StringValue<'ctx>) -> Self {
-        value.as_base_value()
-    }
-}

nac3core/src/codegen/values/tuple.rs

@@ -45,7 +45,7 @@ impl<'ctx> TupleValue<'ctx> {
     }
 
     /// Stores a value into the tuple element at the given `index`.
-    pub fn insert_element(
+    pub fn store_element(
         &mut self,
         ctx: &CodeGenContext<'ctx, '_>,
         index: u32,
@@ -63,11 +63,7 @@ impl<'ctx> TupleValue<'ctx> {
     }
 
     /// Loads a value from the tuple element at the given `index`.
-    pub fn extract_element(
-        &self,
-        ctx: &CodeGenContext<'ctx, '_>,
-        index: u32,
-    ) -> BasicValueEnum<'ctx> {
+    pub fn load_element(&self, ctx: &CodeGenContext<'ctx, '_>, index: u32) -> BasicValueEnum<'ctx> {
         ctx.builder
             .build_extract_value(
                 self.value,

nac3core/src/toplevel/builtins.rs

@@ -36,7 +36,9 @@ pub fn get_exn_constructor(
     unifier: &mut Unifier,
     primitives: &PrimitiveStore,
 ) -> (TopLevelDef, TopLevelDef, Type, Type) {
-    let PrimitiveStore { int32, int64, str: string, .. } = *primitives;
+    let int32 = primitives.int32;
+    let int64 = primitives.int64;
+    let string = primitives.str;
     let exception_fields = make_exception_fields(int32, int64, string);
     let exn_cons_args = vec![
         FuncArg {

nac3core/src/toplevel/composer.rs

@@ -1521,7 +1521,8 @@ impl TopLevelComposer {
                     .any(|ann| matches!(ann, TypeAnnotation::CustomClass { id, .. } if id.0 == 7))
                 {
                     // create constructor for these classes
-                    let PrimitiveStore { str: string, int64, .. } = *primitives_ty;
+                    let string = primitives_ty.str;
+                    let int64 = primitives_ty.int64;
                     let signature = unifier.add_ty(TypeEnum::TFunc(FunSignature {
                         args: vec![
                             FuncArg {

nac3standalone/Cargo.toml

@@ -6,6 +6,7 @@ edition = "2021"
 
 [features]
 no-escape-analysis = ["nac3core/no-escape-analysis"]
+tracing = ["nac3core/tracing"]
 
 [dependencies]
 parking_lot = "0.12"

nac3standalone/demo/demo.c

@@ -65,7 +65,7 @@ struct cslice {
     size_t len;
 };
 
-void output_int32_list(struct cslice* slice) {
+void output_int32_list(const struct cslice* slice) {
     const int32_t* data = (int32_t*)slice->data;
 
     putchar('[');
@@ -80,7 +80,7 @@ void output_int32_list(struct cslice* slice) {
     putchar('\n');
 }
 
-void output_str(struct cslice* slice) {
+void output_str(const struct cslice* slice) {
     const char* data = (const char*)slice->data;
 
     for (size_t i = 0; i < slice->len; ++i) {
@@ -88,12 +88,12 @@ void output_str(struct cslice* slice) {
     }
 }
 
-void output_strln(struct cslice* slice) {
+void output_strln(const struct cslice* slice) {
     output_str(slice);
     putchar('\n');
 }
 
-uint64_t dbg_stack_address(__attribute__((unused)) struct cslice* slice) {
+uint64_t dbg_stack_address(__attribute__((unused)) const struct cslice* slice) {
     int i;
     void* ptr = (void*)&i;
     return (uintptr_t)ptr;

nac3standalone/src/main.rs

@@ -15,8 +15,11 @@ use parking_lot::{Mutex, RwLock};
 
 use nac3core::{
     codegen::{
-        concrete_type::ConcreteTypeStore, irrt::load_irrt, CodeGenLLVMOptions,
-        CodeGenTargetMachineOptions, CodeGenTask, DefaultCodeGenerator, WithCall, WorkerRegistry,
+        concrete_type::ConcreteTypeStore,
+        irrt::load_irrt,
+        tracert::{load_tracert, TraceRuntimeConfig},
+        CodeGenLLVMOptions, CodeGenTargetMachineOptions, CodeGenTask, DefaultCodeGenerator,
+        WithCall, WorkerRegistry,
     },
     inkwell::{
         memory_buffer::MemoryBuffer, module::Linkage, passes::PassBuilderOptions,
@@ -76,6 +79,9 @@ struct CommandLineArgs {
     /// Additional target features to enable/disable, specified using the `+`/`-` prefixes.
     #[arg(long)]
     target_features: Option<String>,
+
+    #[arg(long)]
+    trace: Vec<String>,
 }
 
 fn handle_typevar_definition(
@@ -276,8 +282,16 @@ fn handle_global_var(
 
 fn main() {
     let cli = CommandLineArgs::parse();
-    let CommandLineArgs { file_name, threads, opt_level, emit_llvm, triple, mcpu, target_features } =
-        cli;
+    let CommandLineArgs {
+        file_name,
+        threads,
+        opt_level,
+        emit_llvm,
+        triple,
+        mcpu,
+        target_features,
+        trace,
+    } = cli;
 
     Target::initialize_all(&InitializationConfig::default());
 
@@ -306,6 +320,7 @@ fn main() {
         // The default behavior for -O<n> where n>3 defaults to O3 for both Clang and GCC
         _ => OptimizationLevel::Aggressive,
     };
+    let tracert_config = TraceRuntimeConfig { enabled_tags: trace };
 
     let target_machine_options = CodeGenTargetMachineOptions {
         triple,
@@ -350,6 +365,14 @@ fn main() {
         irrt.write_bitcode_to_path(Path::new("irrt.bc"));
     }
 
+    // Process tracert
+    let tracert = load_tracert(&context, &tracert_config);
+    if let Some(tracert) = &tracert {
+        if emit_llvm {
+            tracert.write_bitcode_to_path(Path::new("tracert.bc"));
+        }
+    }
+
     // Process the Python script
     let parser_result = parser::parse_program(&program, file_name.into()).unwrap();
 
@@ -464,7 +487,8 @@ fn main() {
             ))
         })
         .collect();
-    let (registry, handles) = WorkerRegistry::create_workers(threads, top_level, &llvm_options, &f);
+    let (registry, handles) =
+        WorkerRegistry::create_workers(threads, top_level, &llvm_options, &tracert_config, &f);
     registry.add_task(task);
     registry.wait_tasks_complete(handles);
 
@@ -490,6 +514,9 @@ fn main() {
     }
 
     main.link_in_module(irrt).unwrap();
+    if let Some(tracert) = tracert {
+        main.link_in_module(tracert).unwrap();
+    }
 
     // Private all functions except "run"
     let mut function_iter = main.get_first_function();