llvm_quick 181.0.0-alpha.7

Rust's wrapper for llvm.
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

use std::ffi::CStr;
use std::fmt::{Debug, Formatter};

use llvm_sys::core::*;

use crate::type_tag::*;
use crate::*;

impl Debug for BasicBlock {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.get_name().to_str().unwrap())
    }
}

impl BasicBlock {
    pub fn as_value(&self) -> &Value<label> {
        unsafe { Value::from_raw(LLVMBasicBlockAsValue(self.as_raw())) }
    }
}

impl<T: TypeTag> Value<T> {
    pub fn is_basic_block(&self) -> bool {
        unsafe { LLVMValueIsBasicBlock(self.as_raw()) != 0 }
    }
}

impl Value<label> {
    pub fn as_basic_block(&self) -> &BasicBlock {
        unsafe { BasicBlock::from_raw(LLVMValueAsBasicBlock(self.as_raw())) }
    }
}

impl BasicBlock {
    pub fn get_name(&self) -> &CStr {
        unsafe { CStr::from_ptr(LLVMGetBasicBlockName(self.as_raw())) }
    }

    pub fn get_parent(&self) -> &Value<label> {
        unsafe { Value::from_raw(LLVMGetBasicBlockParent(self.as_raw())) }
    }

    pub fn get_terminator(&self) -> &Value<any> {
        unsafe { Value::from_raw(LLVMGetBasicBlockTerminator(self.as_raw())) }
    }
}

impl<T: FunTypeTag> Function<T> {
    pub fn count_basic_block(&self) -> u32 {
        unsafe { LLVMCountBasicBlocks(self.as_raw()) }
    }

    pub fn get_basic_blocks<'a, 'c>(
        &'c self,
        basic_blocks: &'a mut [Option<&'c BasicBlock>],
    ) -> &'a mut [&'c BasicBlock] {
        assert_eq!(basic_blocks.len(), self.count_basic_block() as usize);
        unsafe {
            LLVMGetBasicBlocks(self.as_raw(), basic_blocks.as_mut_ptr() as _);
            &mut *(basic_blocks as *mut [Option<&BasicBlock>] as *mut [&BasicBlock])
        }
    }

    pub fn get_first_basic_block(&self) -> &BasicBlock {
        unsafe { BasicBlock::from_raw(LLVMGetFirstBasicBlock(self.as_raw())) }
    }

    pub fn get_last_basic_block(&self) -> &BasicBlock {
        unsafe { BasicBlock::from_raw(LLVMGetLastBasicBlock(self.as_raw())) }
    }
}

impl BasicBlock {
    pub fn get_next(&self) -> &Self {
        unsafe { Self::from_raw(LLVMGetNextBasicBlock(self.as_raw())) }
    }

    pub fn get_previous(&self) -> &Self {
        unsafe { Self::from_raw(LLVMGetPreviousBasicBlock(self.as_raw())) }
    }
}

impl<T: FunTypeTag> Function<T> {
    pub fn get_entry_basic_block(&self) -> &BasicBlock {
        unsafe { BasicBlock::from_raw(LLVMGetEntryBasicBlock(self.as_raw())) }
    }
}

impl<'c> Builder<'c> {
    pub fn insert_existing_basic_block_after_insert_block(&self, bb: &BasicBlock) {
        unsafe { LLVMInsertExistingBasicBlockAfterInsertBlock(self.as_raw(), bb.as_raw()) }
    }
}

impl<T: FunTypeTag> Function<T> {
    pub fn append_existing_basic_block(&self, bb: &BasicBlock) {
        unsafe { LLVMAppendExistingBasicBlock(self.as_raw(), bb.as_raw()) }
    }
}

impl Context {
    pub fn create_basic_block(&self, name: &CStr) -> &BasicBlock {
        unsafe { BasicBlock::from_raw(LLVMCreateBasicBlockInContext(self.as_raw(), name.as_ptr())) }
    }

    pub fn append_basic_block<T: FunTypeTag>(&self, f: &Function<T>, name: &CStr) -> &BasicBlock {
        unsafe {
            let ptr = LLVMAppendBasicBlockInContext(self.as_raw(), f.as_raw(), name.as_ptr());
            BasicBlock::from_raw(ptr)
        }
    }

    pub fn insert_basic_block(&self, bb: &BasicBlock, name: &CStr) -> &BasicBlock {
        unsafe {
            BasicBlock::from_raw(LLVMInsertBasicBlockInContext(
                self.as_raw(),
                bb.as_raw(),
                name.as_ptr(),
            ))
        }
    }
}

impl BasicBlock {
    pub fn delete(&self) {
        unsafe { LLVMDeleteBasicBlock(self.as_raw()) }
    }

    pub fn remove_from_parent(&self) {
        unsafe { LLVMRemoveBasicBlockFromParent(self.as_raw()) }
    }

    pub fn move_basic_block_before(&self, move_pos: &BasicBlock) {
        unsafe { LLVMMoveBasicBlockBefore(self.as_raw(), move_pos.as_raw()) }
    }

    pub fn move_basic_block_after(&self, move_pos: &BasicBlock) {
        unsafe { LLVMMoveBasicBlockAfter(self.as_raw(), move_pos.as_raw()) }
    }

    pub fn get_first_instruction(&self) -> &Value<any> {
        unsafe { Value::from_raw(LLVMGetFirstInstruction(self.as_raw())) }
    }

    pub fn get_last_instruction(&self) -> &Value<any> {
        unsafe { Value::from_raw(LLVMGetLastInstruction(self.as_raw())) }
    }
}