libjuno 0.1.5

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

use inkwell::types::BasicTypeEnum;
use inkwell::types::FunctionType;
use inkwell::types::StructType;
use inkwell::values::StructValue;

use std::collections::HashMap;

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<FunctionId, FunctionValue<'ctx>>,

    pub structs: HashMap<TypeId, StructType<'ctx>>,
    pub scopes: Vec<Scope<'ctx>>,

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

    pub current_struct: Option<StructType<'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(),
            structs: HashMap::new(),
            builtins: HashMap::new(),
            scopes: Vec::new(),

            loop_stack: Vec::new(),

            current_function: None,
            current_struct: None
        };
        s.declare_builtins();
        s
    }
    pub fn dump_ir(&self) {
        self.module.print_to_stderr();
    }

    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))
    }
}