1extern crate llvm_sys;
2extern crate libc;
3
4mod builder;
5mod module;
6mod function;
7mod context;
8mod engine;
9mod phi;
10mod struct_type;
11mod cstring_manager;
12
13pub use self::llvm_sys::core::*;
14pub use self::llvm_sys::prelude::*;
15pub use self::builder::Builder;
16pub use self::module::Module;
17pub use self::function::Function;
18pub use self::context::Context;
19pub use self::phi::Phi;
20pub use self::engine::{Engine, FuncallResult};
21pub use self::struct_type::Struct;
22pub use self::llvm_sys::*;
23
24#[allow(non_snake_case)]
25pub mod LLVM {
26 use llvm_sys::core::*;
27 use llvm_sys::target;
28 use llvm_sys::prelude::*;
29 use std::os::raw::c_uint;
30
31 pub fn initialize(){
32 unsafe {
33 if target::LLVM_InitializeNativeTarget() != 0 {
34 panic!("Could not initialise target");
35 }
36 if target::LLVM_InitializeNativeAsmPrinter() != 0 {
37 panic!("Could not initialise ASM Printer");
38 }
39 }
40 }
41
42 pub mod Type {
43 use super::*;
44
45 #[inline]
46 pub fn PointerType(elem_type: LLVMTypeRef, address_space: c_uint) -> LLVMTypeRef {
47 unsafe { LLVMPointerType(elem_type, address_space) }
48 }
49 #[inline]
50 pub fn Pointer(elem_type: LLVMTypeRef, address_space: c_uint) -> LLVMTypeRef {
51 unsafe { LLVMPointerType(elem_type, address_space) }
52 }
53 #[inline]
54 pub fn Void() -> LLVMTypeRef {
55 unsafe { LLVMVoidType() }
56 }
57 #[inline]
58 pub fn Int(num_bits: c_uint) -> LLVMTypeRef {
59 unsafe { LLVMIntType(num_bits) }
60 }
61 #[inline]
62 pub fn Int1() -> LLVMTypeRef {
63 unsafe { LLVMInt1Type() }
64 }
65 #[inline]
66 pub fn Int8() -> LLVMTypeRef {
67 unsafe { LLVMInt8Type() }
68 }
69 #[inline]
70 pub fn Int16() -> LLVMTypeRef {
71 unsafe { LLVMInt16Type() }
72 }
73 #[inline]
74 pub fn Int32() -> LLVMTypeRef {
75 unsafe { LLVMInt32Type() }
76 }
77 #[inline]
78 pub fn Int64() -> LLVMTypeRef {
79 unsafe { LLVMInt64Type() }
80 }
81 #[inline]
82 pub fn Int128() -> LLVMTypeRef {
83 unsafe { LLVMInt128Type() }
84 }
85 #[inline]
86 pub fn Half() -> LLVMTypeRef {
87 unsafe { LLVMHalfType() }
88 }
89 #[inline]
90 pub fn Float() -> LLVMTypeRef {
91 unsafe { LLVMFloatType() }
92 }
93 #[inline]
94 pub fn Double() -> LLVMTypeRef {
95 unsafe { LLVMDoubleType() }
96 }
97 #[inline]
98 pub fn FP128() -> LLVMTypeRef {
99 unsafe { LLVMFP128Type() }
100 }
101 #[inline]
102 pub fn X86FP80() -> LLVMTypeRef {
103 unsafe { LLVMX86FP80Type() }
104 }
105 #[inline]
106 pub fn PPCFP128() -> LLVMTypeRef {
107 unsafe { LLVMPPCFP128Type() }
108 }
109 #[inline]
110 pub fn X86MMX() -> LLVMTypeRef {
111 unsafe { LLVMX86MMXType() }
112 }
113 #[inline]
114 pub fn Label() -> LLVMTypeRef {
115 unsafe { LLVMLabelType() }
116 }
117 #[inline]
118 pub fn CharPointer() -> LLVMTypeRef {
119 Type::PointerType(Type::Int8(), 0)
120 }
121 #[inline]
122 pub fn Int8Pointer() -> LLVMTypeRef {
123 Type::PointerType(Type::Int8(), 0)
124 }
125 }
126
127 pub mod Const {
128 use super::*;
129
130 #[inline]
131 pub fn SInt(num_bits: c_uint, val: u64) -> LLVMValueRef {
132 unsafe { LLVMConstInt(LLVMIntType(num_bits), val, 1) }
133 }
134 #[inline]
135 pub fn UInt(num_bits: c_uint, val: u64) -> LLVMValueRef {
136 unsafe { LLVMConstInt(LLVMIntType(num_bits), val, 0) }
137 }
138 #[inline]
139 pub fn SInt1(val: u64) -> LLVMValueRef {
140 unsafe { LLVMConstInt(LLVMInt1Type(), val, 1) }
141 }
142 #[inline]
143 pub fn UInt1(val: u64) -> LLVMValueRef {
144 unsafe { LLVMConstInt(LLVMInt1Type(), val, 0) }
145 }
146 #[inline]
147 pub fn SInt8(val: u64) -> LLVMValueRef {
148 unsafe { LLVMConstInt(LLVMInt8Type(), val, 1) }
149 }
150 #[inline]
151 pub fn UInt8(val: u64) -> LLVMValueRef {
152 unsafe { LLVMConstInt(LLVMInt8Type(), val, 0) }
153 }
154 #[inline]
155 pub fn SInt16(val: u64) -> LLVMValueRef {
156 unsafe { LLVMConstInt(LLVMInt16Type(), val, 1) }
157 }
158 #[inline]
159 pub fn UInt16(val: u64) -> LLVMValueRef {
160 unsafe { LLVMConstInt(LLVMInt16Type(), val, 0) }
161 }
162 #[inline]
163 pub fn SInt32(val: u64) -> LLVMValueRef {
164 unsafe { LLVMConstInt(LLVMInt32Type(), val, 1) }
165 }
166 #[inline]
167 pub fn UInt32(val: u64) -> LLVMValueRef {
168 unsafe { LLVMConstInt(LLVMInt32Type(), val, 0) }
169 }
170 #[inline]
171 pub fn SInt64(val: u64) -> LLVMValueRef {
172 unsafe { LLVMConstInt(LLVMInt64Type(), val, 1) }
173 }
174 #[inline]
175 pub fn UInt64(val: u64) -> LLVMValueRef {
176 unsafe { LLVMConstInt(LLVMInt64Type(), val, 0) }
177 }
178 #[inline]
179 pub fn SInt128(val: u64) -> LLVMValueRef {
180 unsafe { LLVMConstInt(LLVMInt128Type(), val, 1) }
181 }
182 #[inline]
183 pub fn UInt128(val: u64) -> LLVMValueRef {
184 unsafe { LLVMConstInt(LLVMInt128Type(), val, 0) }
185 }
186
187 #[inline]
188 pub fn Half(val: f64) -> LLVMValueRef {
189 unsafe { LLVMConstReal(LLVMHalfType(), val) }
190 }
191 #[inline]
192 pub fn Float(val: f64) -> LLVMValueRef {
193 unsafe { LLVMConstReal(LLVMFloatType(), val) }
194 }
195 #[inline]
196 pub fn Double(val: f64) -> LLVMValueRef {
197 unsafe { LLVMConstReal(LLVMDoubleType(), val) }
198 }
199 #[inline]
200 pub fn FP128(val: f64) -> LLVMValueRef {
201 unsafe { LLVMConstReal(LLVMFP128Type(), val) }
202 }
203 #[inline]
204 pub fn X86FP80(val: f64) -> LLVMValueRef {
205 unsafe { LLVMConstReal(LLVMX86FP80Type(), val) }
206 }
207 #[inline]
208 pub fn PPCFP128(val: f64) -> LLVMValueRef {
209 unsafe { LLVMConstReal(LLVMPPCFP128Type(), val) }
210 }
211 }
212}
213
214#[macro_export]
215macro_rules! fn_type {
216 ($result_type:expr) => (
217 unsafe {
218 let mut param_types = [];
219 LLVMFunctionType($result_type, param_types.as_mut_ptr(), param_types.len() as u32, 0)
220 }
221 );
222 ($result_type:expr,,,) => (
223 unsafe {
224 let mut param_types = [];
225 LLVMFunctionType($result_type, param_types.as_mut_ptr(), param_types.len() as u32, 1)
226 }
227 );
228 ($result_type:expr, $( $param_type:expr ),* ) => (
229 unsafe {
230 let mut param_types = [ $( $param_type ),* ];
231 LLVMFunctionType($result_type, param_types.as_mut_ptr(), param_types.len() as u32, 0)
232 }
233 );
234 ($result_type:expr, $( $param_type:expr ),* ,,,) => (
235 unsafe {
236 let mut param_types = [ $( $param_type ),* ];
237 LLVMFunctionType($result_type, param_types.as_mut_ptr(), param_types.len() as u32, 1)
238 }
239 )
240}