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
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use llvm_sys::core::*;
use llvm_sys::prelude::{LLVMModuleRef, LLVMValueRef};
use std::marker::PhantomData;

use crate::values::*;
use crate::*;

/// LLVM Module
pub struct Module<'ctx>(LLVMModuleRef, PhantomData<&'ctx ()>);

impl_send_sync!(Module);

impl<'ctx> Module<'ctx> {
  pub(crate) fn new(ptr: LLVMModuleRef) -> Self {
    Self(ptr, PhantomData)
  }

  /// Iterate all functions inside the module
  ///
  /// ```
  /// # use llir::*;
  /// # use std::path::*;
  /// # let ctx = Context::create();
  /// # let module = ctx.load_module(PathBuf::from("tests/c_files/basic/example_1.bc"));
  /// for func in module.iter_functions() {
  ///   // Do things with func
  /// }
  /// ```
  pub fn iter_functions(&self) -> ValueIterator<'ctx, Function<'ctx>> {
    ValueIterator {
      curr_value: unsafe { LLVMGetFirstFunction(self.0) },
      next_fn: next_function,
      marker: PhantomData
    }
  }

  /// Get the function by name
  pub fn get_function(&self, name: &str) -> Option<Function<'ctx>> {
    let zero_appended = format!("{}\0", name);
    let fn_ptr = unsafe { LLVMGetNamedFunction(self.0, zero_appended.as_ptr() as *const i8) };
    if fn_ptr.is_null() { None } else { Some(Function::from_llvm(fn_ptr)) }
  }

  /// Iterate all globals variables
  ///
  /// ```
  /// for glob in module.iter_global_variables() {
  ///   // Do things with glob
  /// }
  /// ```
  pub fn iter_global_variables(&self) -> ValueIterator<'ctx, GlobalVariable<'ctx>> {
    ValueIterator {
      curr_value: unsafe { LLVMGetFirstGlobal(self.0) },
      next_fn: next_global,
      marker: PhantomData
    }
  }

  /// Get global variable by name
  pub fn get_global_variable(&self, name: &str) -> Option<GlobalVariable<'ctx>> {
    let zero_appended = format!("{}\0", name);
    let gv_ptr = unsafe { LLVMGetNamedGlobal(self.0, zero_appended.as_ptr() as *const i8) };
    if gv_ptr.is_null() { None } else { Some(GlobalVariable::from_llvm(gv_ptr)) }
  }

  /// Iterate all global aliases
  ///
  /// ```
  /// for glob_alias in module.iter_global_aliases() {
  ///   // Do things with global alias
  /// }
  /// ```
  pub fn iter_global_aliases(&self) -> ValueIterator<'ctx, GlobalAlias<'ctx>> {
    ValueIterator {
      curr_value: unsafe { LLVMGetFirstGlobalAlias(self.0) },
      next_fn: next_global_alias,
      marker: PhantomData,
    }
  }

  /// Get global alias by name
  pub fn get_global_alias(&self, name: &str) -> Option<GlobalAlias<'ctx>> {
    let ga_ptr = unsafe { LLVMGetNamedGlobalAlias(self.0, name.as_ptr() as *const i8, name.len()) };
    if ga_ptr.is_null() { None } else { Some(GlobalAlias::from_llvm(ga_ptr)) }
  }

  /// Iterate all globals, including global variables and global aliases
  ///
  /// ``` rust
  /// for glob in module.iter_globals() {
  ///   match glob {
  ///     Global::Variable(v) => { /* ... */ },
  ///     Global::Alias(a) => { /* ... */ },
  ///   }
  /// }
  /// ```
  pub fn iter_globals(&self) -> GlobalIterator<'ctx> {
    GlobalIterator {
      var_iter: self.iter_global_variables(),
      alias_iter: self.iter_global_aliases(),
    }
  }
}

fn next_function(ptr: LLVMValueRef) -> LLVMValueRef {
  unsafe { LLVMGetNextFunction(ptr) }
}

fn next_global(ptr: LLVMValueRef) -> LLVMValueRef {
  unsafe { LLVMGetNextGlobal(ptr) }
}

fn next_global_alias(ptr: LLVMValueRef) -> LLVMValueRef {
  unsafe { LLVMGetNextGlobalAlias(ptr) }
}

#[doc(hidden)]
pub struct ValueIterator<'ctx, T> where T : FromLLVMValue {
  curr_value: LLVMValueRef,
  next_fn: fn(LLVMValueRef) -> LLVMValueRef,
  marker: PhantomData<&'ctx T>,
}

impl<'ctx, T> Iterator for ValueIterator<'ctx, T> where T : FromLLVMValue {
  type Item = T;

  fn next(&mut self) -> Option<Self::Item> {
    if self.curr_value.is_null() {
      None
    } else {
      let result = Some(T::from_llvm(self.curr_value));
      self.curr_value = (self.next_fn)(self.curr_value);
      result
    }
  }
}

#[doc(hidden)]
pub struct GlobalIterator<'ctx> {
  var_iter: ValueIterator<'ctx, GlobalVariable<'ctx>>,
  alias_iter: ValueIterator<'ctx, GlobalAlias<'ctx>>,
}

impl<'ctx> Iterator for GlobalIterator<'ctx> {
  type Item = Global<'ctx>;

  fn next(&mut self) -> Option<Self::Item> {
    match self.var_iter.next() {
      Some(gv) => Some(gv.as_global()),
      None => match self.alias_iter.next() {
        Some(ga) => Some(ga.as_global()),
        None => None
      }
    }
  }
}