remir_llvm 1.0.0

The LLVM binding for the Remir 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
102
103
104
105
106
107
108

use std::hint::unreachable_unchecked;

use inkwell::values::{BasicValue, BasicValueEnum, FastMathFlags};
use remir::{block::BlockInstruction, insts::Instruction, misc::MathOperator};

use crate::{LLVMBridge, llvm_to_base, llvm_to_base_returnless, utils::LLVMBasicValue};

pub fn bridge_llvm_math_instruction(
    instruction: BlockInstruction,
    bridge: &mut LLVMBridge,
) -> Result<Option<LLVMBasicValue>, ()> {
    let res: Option<BasicValueEnum<'static>> = match &instruction.instruction {
        Instruction::MathOperationInt {
            a,
            b,
            op,
            signed,
            signed_wrap,
            unsigned_wrap,
            fast: _,
        } => {
            let a = bridge.values[&a.base.inst_ind].into_int_value();
            let b = bridge.values[&b.base.inst_ind].into_int_value();

            let res = match op {
                MathOperator::Add => bridge.builder.build_int_add(a, b, ""),
                MathOperator::Sub => bridge.builder.build_int_sub(a, b, ""),
                MathOperator::Mul => bridge.builder.build_int_mul(a, b, ""),
                MathOperator::Div => {
                    if *signed {
                        bridge.builder.build_int_signed_div(a, b, "")
                    } else {
                        bridge.builder.build_int_unsigned_div(a, b, "")
                    }
                }

                MathOperator::Mod => {
                    if *signed {
                        bridge.builder.build_int_signed_rem(a, b, "")
                    } else {
                        bridge.builder.build_int_unsigned_rem(a, b, "")
                    }
                }

                MathOperator::And => bridge.builder.build_and(a, b, ""),
                MathOperator::Or => bridge.builder.build_or(a, b, ""),
                MathOperator::Xor => bridge.builder.build_xor(a, b, ""),
                MathOperator::Shl => bridge.builder.build_left_shift(a, b, ""),
                MathOperator::Shr => bridge.builder.build_right_shift(a, b, *signed, ""),
            };

            let res = llvm_to_base!(res);

            if let Some(res2) = res.as_instruction_value() {
                llvm_to_base_returnless!(res2.set_no_signed_wrap_flag(!*signed_wrap));
                llvm_to_base_returnless!(res2.set_no_unsigned_wrap_flag(!*unsigned_wrap));
            }

            Some(res.into())
        }

        Instruction::MathOperationFloat {
            a,
            b,
            op,
            signed_wrap,
            unsigned_wrap,
            fast,
        } => {
            let a = bridge.values[&a.base.inst_ind].into_float_value();
            let b = bridge.values[&b.base.inst_ind].into_float_value();

            let res = match op {
                MathOperator::Add => bridge.builder.build_float_add(a, b, ""),
                MathOperator::Sub => bridge.builder.build_float_sub(a, b, ""),
                MathOperator::Mul => bridge.builder.build_float_mul(a, b, ""),
                MathOperator::Div => bridge.builder.build_float_div(a, b, ""),
                MathOperator::Mod => bridge.builder.build_float_rem(a, b, ""),

                _ => panic!(),
            };

            let res = llvm_to_base!(res);
            let res2 = res.as_instruction().unwrap();

            llvm_to_base_returnless!(res2.set_no_signed_wrap_flag(!*signed_wrap));
            llvm_to_base_returnless!(res2.set_no_unsigned_wrap_flag(!*unsigned_wrap));

            let mut flags = FastMathFlags::empty();

            if *fast {
                flags = FastMathFlags::all();
            }

            llvm_to_base_returnless!(res2.set_fast_math_flags(flags));

            Some(res.into())
        }

        _ => unsafe { unreachable_unchecked() },
    };

    if res.is_some() {
        return Ok(Some(LLVMBasicValue::new(res.unwrap(), &bridge.ctx)));
    }

    return Ok(None);
}