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

use remir::{block::BlockInstruction, func::FunctionReference, insts::Instruction, module::Module};

use crate::{
    LLVMBridge,
    inst::{
        atomic::bridge_llvm_atomic_instruction, branches::bridge_llvm_branch_instruction,
        cmp::bridge_llvm_cmp_instruction, consts::bridge_llvm_const_instruction,
        funcs::bridge_llvm_function_instruction, hints::bridge_llvm_hints_instruction,
        math::bridge_llvm_math_instruction, mem::bridge_llvm_mem_instruction,
        regs::bridge_llvm_reg_instructions, structs::bridge_llvm_struct_instruction,
        vals::bridge_llvm_vals_instruction,
    },
    utils::LLVMBasicValue,
};

pub mod atomic;
pub mod branches;
pub mod cmp;
pub mod consts;
pub mod funcs;
pub mod hints;
pub mod math;
pub mod mem;
pub mod regs;
pub mod structs;
pub mod vals;

pub fn bridge_llvm_instruction(
    instruction: BlockInstruction,
    bridge: &mut LLVMBridge,
    func: FunctionReference,
    module: &mut Module,
) -> Result<Option<LLVMBasicValue>, ()> {
    match &instruction.instruction {
        Instruction::ConstInt { .. }
        | Instruction::ConstFloat { .. }
        | Instruction::ConstPointer { .. }
        | Instruction::ConstString { .. }
        | Instruction::ConstStruct { .. } => {
            bridge_llvm_const_instruction(instruction, bridge, module)
        }
        Instruction::Copy { .. } | Instruction::Load { .. } | Instruction::Store { .. } => {
            bridge_llvm_reg_instructions(instruction, bridge)
        }

        Instruction::MathOperationInt { .. } | Instruction::MathOperationFloat { .. } => {
            bridge_llvm_math_instruction(instruction, bridge)
        }

        Instruction::CompareOperationInt { .. } | Instruction::CompareOperationFloat { .. } => {
            bridge_llvm_cmp_instruction(instruction, bridge)
        }

        Instruction::UncondBr { .. }
        | Instruction::Condbr { .. }
        | Instruction::IndirectBranch { .. }
        | Instruction::Phi { .. } => bridge_llvm_branch_instruction(instruction, bridge),

        Instruction::Call { .. }
        | Instruction::RetNull
        | Instruction::Ret { .. }
        | Instruction::GrabArgument { .. } => {
            bridge_llvm_function_instruction(instruction, func, bridge)
        }

        Instruction::Alloc { .. }
        | Instruction::AllocUntyped { .. }
        | Instruction::Alloca { .. }
        | Instruction::AllocaUntyped { .. }
        | Instruction::Free { .. }
        | Instruction::Gep { .. }
        | Instruction::LoadIndexed { .. }
        | Instruction::StoreIndexed { .. } => {
            bridge_llvm_mem_instruction(instruction, bridge, module)
        }

        Instruction::IntToFloat { .. }
        | Instruction::FloatToInt { .. }
        | Instruction::IntExtend { .. }
        | Instruction::IntTruncate { .. }
        | Instruction::FloatExtend { .. }
        | Instruction::FloatTruncate { .. } => bridge_llvm_vals_instruction(instruction, bridge),

        Instruction::Select { .. }
        | Instruction::ExtractValue { .. }
        | Instruction::InsertValue { .. }
        | Instruction::Switch { .. } => bridge_llvm_struct_instruction(instruction, bridge),

        Instruction::LoadAtomic { .. } | Instruction::StoreAtomic { .. } => {
            bridge_llvm_atomic_instruction(instruction, bridge)
        }

        Instruction::Assume { .. }
        | Instruction::Crash { .. }
        | Instruction::BitCast { .. }
        | Instruction::Unreachable => bridge_llvm_hints_instruction(instruction, bridge, module),
    }
}