llir 0.2.2

LLVM IR Binding
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

#[allow(deprecated)]
use llvm_sys::bit_reader::LLVMParseBitcodeInContext;
use llvm_sys::core::*;
use llvm_sys::prelude::LLVMContextRef;
use std::mem::MaybeUninit;
use std::path::Path;

use super::utils::mem_buffer::MemoryBuffer;
use super::utils::support::LLVMString;
use super::Module;

/// LLVM Context
///
/// ```
/// # use llir::Context;
/// let ctx = Context::create();
/// ```
#[derive(Debug, PartialEq, Eq)]
pub struct Context(LLVMContextRef);

unsafe impl Send for Context {}

unsafe impl Sync for Context {}

impl Context {
  pub(crate) fn new(context: LLVMContextRef) -> Self {
    Self(context)
  }

  /// Create a new context
  pub fn create() -> Self {
    let context = unsafe { LLVMContextCreate() };
    Self::new(context)
  }

  /// Load a module
  ///
  /// ```
  /// # use llir::Context;
  /// # let ctx = Context::create();
  /// let module = ctx.load_module(Path::new("tests/c_files/basic/example_1.bc"))?;
  /// ```
  pub fn load_module<'ctx, P>(&'ctx self, path: P) -> Result<Module<'ctx>, String>
  where
    P: AsRef<Path>,
  {
    let buffer = MemoryBuffer::create_from_file(path.as_ref())?;
    let mut module = MaybeUninit::uninit();
    let mut err_string = MaybeUninit::uninit();
    #[allow(deprecated)]
    let success = unsafe {
      LLVMParseBitcodeInContext(
        self.0,
        buffer.memory_buffer,
        module.as_mut_ptr(),
        err_string.as_mut_ptr(),
      )
    };
    if success != 0 {
      let err_string = unsafe { err_string.assume_init() };
      return Err(LLVMString::new(err_string).to_string());
    }

    let module = unsafe { module.assume_init() };

    Ok(Module::new(module))
  }
}

impl Drop for Context {
  fn drop(&mut self) {
    unsafe { LLVMContextDispose(self.0) }
  }
}