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
62
63
64
65
66

use std::path::Path;

use inkwell::{
    module::Module,
    targets::{
        CodeModel, FileType, InitializationConfig, RelocMode, Target, TargetMachine, TargetTriple,
    },
};

use crate::{compiler::OptimizationLevel, error::PrismError};

pub struct CodeGenerator {
    machine: TargetMachine,
}

impl CodeGenerator {
    pub fn native(optimization: OptimizationLevel) -> Result<Self, PrismError> {
        Target::initialize_all(&InitializationConfig::default());

        let triple = TargetMachine::get_default_triple();

        Self::for_triple(triple, optimization)
    }

    pub fn for_triple(
        triple: TargetTriple,
        optimization: OptimizationLevel,
    ) -> Result<Self, PrismError> {
        let target =
            Target::from_triple(&triple).map_err(|err| PrismError::Compilation(err.to_string()))?;

        let machine = target
            .create_target_machine(
                &triple,
                "generic",
                "",
                optimization.llvm_level(),
                RelocMode::Default,
                CodeModel::Default,
            )
            .ok_or_else(|| {
                PrismError::Compilation("LLVM could not create a target machine.".into())
            })?;

        Ok(Self { machine })
    }

    pub fn emit_object(&self, module: &Module<'_>, path: &Path) -> Result<(), PrismError> {
        module.set_triple(&self.machine.get_triple());

        let data_layout = self.machine.get_target_data().get_data_layout();
        module.set_data_layout(&data_layout);

        module
            .verify()
            .map_err(|err| PrismError::Compilation(err.to_string()))?;

        self.machine
            .write_to_file(module, FileType::Object, path)
            .map_err(|err| PrismError::Compilation(err.to_string()))
    }

    pub fn target_machine(&self) -> &TargetMachine {
        &self.machine
    }
}