llvm-plugin 0.6.0

A wrapper for easily implementing out-of-source-tree LLVM plugins in Rust.
Documentation 
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
128
129
130
131
132
133
134
135

use std::ffi::c_void;

use inkwell::module::Module;
use inkwell::values::FunctionValue;
use inkwell_internals::llvm_versions;

use super::{
    FunctionAnalysisManager, LlvmFunctionPass, LlvmModulePass, ModuleAnalysisManager,
    PreservedAnalyses,
};

/// Struct allowing to add passes on LLVM IR modules to the pass manager
/// pipeline.
pub struct ModulePassManager {
    inner: *mut c_void,
}

impl ModulePassManager {
    #[doc(hidden)]
    pub unsafe fn from_raw(pass_manager: *mut c_void) -> Self {
        Self {
            inner: pass_manager,
        }
    }

    /// Adds a pass to this pass manager.
    pub fn add_pass<T>(&mut self, pass: T)
    where
        T: LlvmModulePass,
    {
        let pass = Box::new(pass);

        extern "C" fn pass_deleter<T>(pass: *mut c_void) {
            drop(unsafe { Box::<T>::from_raw(pass.cast()) })
        }

        extern "C" fn pass_entrypoint<T>(
            pass: *mut c_void,
            module: *mut c_void,
            manager: *mut c_void,
        ) -> PreservedAnalyses
        where
            T: LlvmModulePass,
        {
            let pass = unsafe { Box::<T>::from_raw(pass.cast()) };
            let mut module = unsafe { Module::new(module.cast()) };
            let manager = unsafe { ModuleAnalysisManager::from_raw(manager, None) };

            let preserve = pass.run_pass(&mut module, &manager);

            Box::into_raw(pass);
            std::mem::forget(module);

            preserve
        }

        unsafe {
            super::modulePassManagerAddPass(
                self.inner,
                Box::into_raw(pass).cast(),
                pass_deleter::<T>,
                pass_entrypoint::<T>,
            )
        }
    }

    /// Returns if the pass manager contains any passes.
    #[llvm_versions(12..)]
    pub fn is_empty(&self) -> bool {
        unsafe { super::modulePassManagerIsEmpty(self.inner) }
    }
}

/// Struct allowing to add passes on LLVM IR functions to the pass manager
/// pipeline.
pub struct FunctionPassManager {
    inner: *mut c_void,
}

impl FunctionPassManager {
    #[doc(hidden)]
    pub unsafe fn from_raw(pass_manager: *mut c_void) -> Self {
        Self {
            inner: pass_manager,
        }
    }

    /// Adds a pass to this pass manager.
    pub fn add_pass<T>(&mut self, pass: T)
    where
        T: LlvmFunctionPass,
    {
        let pass = Box::new(pass);

        extern "C" fn pass_deleter<T>(pass: *mut c_void) {
            drop(unsafe { Box::<T>::from_raw(pass.cast()) })
        }

        extern "C" fn pass_entrypoint<T>(
            pass: *mut c_void,
            function: *mut c_void,
            manager: *mut c_void,
        ) -> PreservedAnalyses
        where
            T: LlvmFunctionPass,
        {
            let pass = unsafe { Box::<T>::from_raw(pass.cast()) };
            let mut function = unsafe { FunctionValue::new(function.cast()).unwrap() };
            let manager = unsafe { FunctionAnalysisManager::from_raw(manager, None) };

            let preserve = pass.run_pass(&mut function, &manager);

            Box::into_raw(pass);
            #[allow(forgetting_copy_types)]
            std::mem::forget(function);

            preserve
        }

        unsafe {
            super::functionPassManagerAddPass(
                self.inner,
                Box::into_raw(pass).cast(),
                pass_deleter::<T>,
                pass_entrypoint::<T>,
            )
        }
    }

    /// Returns if the pass manager contains any passes.
    #[llvm_versions(12..)]
    pub fn is_empty(&self) -> bool {
        unsafe { super::functionPassManagerIsEmpty(self.inner) }
    }
}