hllvm-sys 0.1.3

FFI wrapper around the LLVM C++ library
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

use {TypeRef, ContextRef};

use libc;

cpp! {
    #include "ffi_helpers.h"

    #include "llvm/IR/Module.h"
    #include "llvm/IR/LLVMContext.h"

    pub fn LLVMRustTypeGetVoidTy(context: ContextRef as "llvm::LLVMContext*")
        -> TypeRef as "llvm::Type*" {
        return llvm::Type::getVoidTy(*context);
    }

    pub fn LLVMRustTypeDump(ty: TypeRef as "llvm::Type*") {
        ty->dump();
    }

    pub fn LLVMRustIntegerTypeGet(context: ContextRef as "llvm::LLVMContext*",
                                  num_bits: libc::c_int as "int")
        -> TypeRef as "llvm::Type*" {
        return llvm::IntegerType::get(*context, num_bits);
    }

    pub fn LLVMRustFunctionTypeGet(result: TypeRef as "llvm::Type*",
                                   params: &[TypeRef] as "support::Slice<llvm::Type*>",
                                   is_var_arg: bool as "bool")
        -> TypeRef as "llvm::Type*" {
        return llvm::FunctionType::get(result, params.ref(), is_var_arg);
    }

    pub fn LLVMRustStructTypeGet(context: ContextRef as "llvm::LLVMContext*",
                                 elements: &[TypeRef] as "support::Slice<llvm::Type*>",
                                 is_packed: bool as "bool")
        -> TypeRef as "llvm::Type*" {
        return llvm::StructType::get(*context, elements.ref(), is_packed);
    }

    pub fn LLVMRustArrayTypeGet(element_type: TypeRef as "llvm::Type*",
                                num_elements: u64 as "uint64_t")
        -> TypeRef as "llvm::Type*" {
        return llvm::ArrayType::get(element_type, num_elements);
    }

    pub fn LLVMRustVectorTypeGet(element_type: TypeRef as "llvm::Type*",
                                 num_elements: u64 as "uint64_t")
        -> TypeRef as "llvm::Type*" {
        return llvm::VectorType::get(element_type, num_elements);
    }

    pub fn LLVMRustPointerTypeGet(element_type: TypeRef as "llvm::Type*",
                                  address_space: libc::c_uint as "unsigned")
        -> TypeRef as "llvm::Type*" {
        return llvm::PointerType::get(element_type, address_space);
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use test_support::Context;

    #[test]
    fn can_dump_void_type() {
        let ctx = Context::new();

        unsafe {
            let ty = LLVMRustTypeGetVoidTy(ctx.inner);
            ::LLVMRustTypeDump(ty);
        }
    }

    #[test]
    fn can_get_u22_type() {
        let ctx = Context::new();

        unsafe { LLVMRustIntegerTypeGet(ctx.inner, 22) };
    }

    #[test]
    fn can_create_void_function_type() {
        let ctx = Context::new();

        unsafe {
            let void = LLVMRustTypeGetVoidTy(ctx.inner);
            LLVMRustFunctionTypeGet(void, &[], false);
        }
    }

    #[test]
    fn can_get_struct_type() {
        let ctx = Context::new();

        let i33 = unsafe { LLVMRustIntegerTypeGet(ctx.inner, 33) };

        unsafe {
            LLVMRustStructTypeGet(ctx.inner, &[i33], false);
        }
    }
}