libjuno 0.1.0

Library for JunoLang
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use inkwell::{module::Linkage, types::BasicTypeEnum};
use inkwell::types::FunctionType;
use inkwell::AddressSpace;

use std::{ collections::HashMap, hash::Hash };

use inkwell::{
    basic_block::BasicBlock,
    builder::Builder,
    context::Context,
    module::Module,
    values::{ FunctionValue, PointerValue },
};

use crate::metair::MetaProgram;

use super::LLVMError;
use crate::ir::scope::Scope;
use crate::metair::*;

pub struct LoopFrame<'ctx> {
    pub break_block: BasicBlock<'ctx>,
    pub continue_block: BasicBlock<'ctx>,
}

pub struct LLVMBackend<'ctx> {
    pub context: &'ctx Context,

    pub module: Module<'ctx>,

    pub builder: Builder<'ctx>,

    pub program: &'ctx MetaProgram,

    pub functions: HashMap<u32, FunctionValue<'ctx>>,

    pub scopes: Vec<Scope<'ctx>>,

    pub current_function: Option<FunctionValue<'ctx>>,

    pub loop_stack: Vec<LoopFrame<'ctx>>,

    pub builtins: HashMap<&'ctx str, FunctionValue<'ctx>>,
}

impl<'ctx> LLVMBackend<'ctx> {
    pub fn new(context: &'ctx Context, program: &'ctx MetaProgram, module_name: &str) -> Self {
        let mut s = Self {
            context,

            module: context.create_module(module_name),

            builder: context.create_builder(),

            program,

            functions: HashMap::new(),
            builtins: HashMap::new(),
            scopes: Vec::new(),

            loop_stack: Vec::new(),

            current_function: None,
        };
        s.declare_builtins();
        s
    }
    pub fn dump_ir(&self) {
        self.module.print_to_stderr();
    }
    pub fn declare_builtin(&mut self, name: &str, ty: FunctionType<'ctx>) -> Result<(), LLVMError> {
        let id = self.program.symbol_table
            .iter()
            .position(|s| s == name)
            .ok_or_else(||
                LLVMError::Message(format!("builtin '{}' not interned", name))
            )? as SymbolId;

        let func = self.module.add_function(name, ty, None);

        self.functions.insert(id, func);

        Ok(())
    }

    pub fn compile(&mut self) -> Result<Module<'ctx>, LLVMError> {
        self.lower_program()?;
        self.module.verify().map_err(|e| { LLVMError::Message(e.to_string()) })?;

        Ok(self.module.clone())
    }
}

impl<'ctx> LLVMBackend<'ctx> {
    pub fn push_scope(&mut self) {
        self.scopes.push(Scope::new());
    }

    pub fn pop_scope(&mut self) {
        self.scopes.pop();
    }

    pub fn current_function(&self) -> FunctionValue<'ctx> {
        self.current_function.unwrap()
    }
    pub fn insert_variable(
        &mut self,
        id: SymbolId,
        ptr: PointerValue<'ctx>,
        ty: BasicTypeEnum<'ctx>
    ) {
        self.scopes.last_mut().unwrap().insert(id, ptr, ty);
    }

    pub fn get_variable(
        &self,
        id: SymbolId
    ) -> Result<&crate::ir::scope::Variable<'ctx>, LLVMError> {
        for scope in self.scopes.iter().rev() {
            if let Some(var) = scope.get(id) {
                return Ok(var);
            }
        }

        Err(LLVMError::UnknownVariable(id))
    }
}