prism-llvm 0.1.0

A Rust abstraction layer for LLVM with a compilation pipeline.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

use inkwell::{
    context::Context as LLVMContext,
    module::{Linkage, Module as LLVMModule},
    types::{BasicMetadataTypeEnum, BasicTypeEnum},
    values::FunctionValue,
};

use crate::types::Type;

pub struct Module<'a> {
    context: &'a LLVMContext,
    module: LLVMModule<'a>,
}

impl<'a> Module<'a> {
    pub fn new(context: &'a LLVMContext, module: LLVMModule<'a>) -> Self {
        Self { context, module }
    }

    pub fn create_function(
        &self,
        name: &str,
        return_type: Type,
        param_types: &[Type],
    ) -> FunctionValue<'_> {
        let mapped_params: Vec<BasicMetadataTypeEnum> = param_types
            .iter()
            .map(|t| {
                t.to_basic_type(self.context)
                    .expect("Cannot use 'Void' as a function parameter type.")
                    .into()
            })
            .collect();

        let fn_type = match return_type {
            Type::Void => self.context.void_type().fn_type(&mapped_params, false),

            _ => {
                let basic_ret = return_type.to_basic_type(self.context).unwrap();

                match basic_ret {
                    BasicTypeEnum::IntType(t) => t.fn_type(&mapped_params, false),
                    BasicTypeEnum::FloatType(t) => t.fn_type(&mapped_params, false),

                    _ => unreachable!(),
                }
            }
        };

        self.module
            .add_function(name, fn_type, Some(Linkage::External))
    }

    pub fn get_ir(&self) -> String {
        self.module.print_to_string().to_string()
    }

    pub fn get_name(&self) -> &str {
        self.module.get_name().to_str().unwrap()
    }
}