fips-md 0.3.0

A framework for simulating arbitrary particle dynamics
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

use llvm_sys::prelude::*;
use llvm_sys::core::*;

use super::{Context, BasicBlock, Value, Type};

pub struct IRBuilder {
    pub builder: LLVMBuilderRef,
    ctx: Context
}

impl IRBuilder {
    pub fn with_context(ctx: &Context) -> IRBuilder { 
        IRBuilder {
            builder: unsafe { LLVMCreateBuilderInContext(ctx.ctx)},
            ctx : ctx.clone()
        }
    }

    pub fn get_context(&self) -> &Context {
        &self.ctx
    }

    pub fn position_at_end(&self, bb: &BasicBlock) {
        unsafe { LLVMPositionBuilderAtEnd(self.builder, bb.bb) }
    }

    pub fn build_ret(&self, val: &Value) {
        unsafe { LLVMBuildRet(self.builder, val.val); }
    }

    // Conversions

    pub fn build_si_to_fp(&self, val: &Value, ty: &Type, name: &str) -> Value {
        let name = self.ctx.store_string(name);
        Value::new( unsafe { LLVMBuildSIToFP(self.builder, val.val, ty.ty, name) })
    }

    // -- Arithmetic operations --

    // Addition

    pub fn build_int_add(&self, lhs: &Value, rhs: &Value, name: &str) -> Value {
        let name = self.ctx.store_string(name);
        Value::new( unsafe { LLVMBuildAdd(self.builder, lhs.val, rhs.val, name) })
    }    

    pub fn build_fp_add(&self, lhs: &Value, rhs: &Value, name: &str) -> Value {
        let name = self.ctx.store_string(name);
        Value::new( unsafe { LLVMBuildFAdd(self.builder, lhs.val, rhs.val, name) })
    }

    // Subtraction

    pub fn build_int_sub(&self, lhs: &Value, rhs: &Value, name: &str) -> Value {
        let name = self.ctx.store_string(name);
        Value::new( unsafe { LLVMBuildSub(self.builder, lhs.val, rhs.val, name) })
    }    

    pub fn build_fp_sub(&self, lhs: &Value, rhs: &Value, name: &str) -> Value {
        let name = self.ctx.store_string(name);
        Value::new( unsafe { LLVMBuildFSub(self.builder, lhs.val, rhs.val, name) })
    }

    // Multiplication
    
    pub fn build_int_mul(&self, lhs: &Value, rhs: &Value, name: &str) -> Value {
        let name = self.ctx.store_string(name);
        Value::new( unsafe { LLVMBuildMul(self.builder, lhs.val, rhs.val, name) })
    }    

    pub fn build_fp_mul(&self, lhs: &Value, rhs: &Value, name: &str) -> Value {
        let name = self.ctx.store_string(name);
        Value::new( unsafe { LLVMBuildFMul(self.builder, lhs.val, rhs.val, name) })
    }

    // Division

    pub fn build_int_sdiv(&self, lhs: &Value, rhs: &Value, name: &str) -> Value {
        let name = self.ctx.store_string(name);
        Value::new( unsafe { LLVMBuildSDiv(self.builder, lhs.val, rhs.val, name) })
    }    

    pub fn build_int_udiv(&self, lhs: &Value, rhs: &Value, name: &str) -> Value {
        let name = self.ctx.store_string(name);
        Value::new( unsafe { LLVMBuildUDiv(self.builder, lhs.val, rhs.val, name) })
    }    

    pub fn build_fp_div(&self, lhs: &Value, rhs: &Value, name: &str) -> Value {
        let name = self.ctx.store_string(name);
        Value::new( unsafe { LLVMBuildFDiv(self.builder, lhs.val, rhs.val, name) })
    }

    // Division remainder (modulo)

    pub fn build_int_srem(&self, lhs: &Value, rhs: &Value, name: &str) -> Value {
        let name = self.ctx.store_string(name);
        Value::new( unsafe { LLVMBuildSRem(self.builder, lhs.val, rhs.val, name) })
    }    

    pub fn build_int_urem(&self, lhs: &Value, rhs: &Value, name: &str) -> Value {
        let name = self.ctx.store_string(name);
        Value::new( unsafe { LLVMBuildURem(self.builder, lhs.val, rhs.val, name) })
    }    

    pub fn build_fp_rem(&self, lhs: &Value, rhs: &Value, name: &str) -> Value {
        let name = self.ctx.store_string(name);
        Value::new( unsafe { LLVMBuildFRem(self.builder, lhs.val, rhs.val, name) })
    }
}

impl Drop for IRBuilder {
    fn drop(&mut self) { unsafe {
        LLVMDisposeBuilder(self.builder);
    }}
}