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::{
    module::Linkage,
    types::StringRadix,
    values::{BasicValueEnum, IntValue},
};
use remir::{block::BlockInstruction, insts::Instruction, module::Module, values::ValueType};

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

pub fn bridge_llvm_const_instruction(
    instruction: BlockInstruction,
    bridge: &mut LLVMBridge,
    module: &mut Module,
) -> Result<Option<LLVMBasicValue>, ()> {
    let res: Option<BasicValueEnum<'static>> = match &instruction.instruction {
        Instruction::ConstInt { val, size, signed } => {
            let ty = bridge
                .type_storage
                .convert(ValueType::Int(*signed, *size))
                .into_int_type();

            let res = ty
                .const_int_from_string(&val.to_string(), StringRadix::Decimal)
                .unwrap();

            Some(res.into())
        }

        Instruction::ConstFloat { val, size } => {
            let ty = bridge
                .type_storage
                .convert(ValueType::Float(*size))
                .into_float_type();

            let res = unsafe { ty.const_float_from_string(&val.to_string()) };

            Some(res.into())
        }

        Instruction::ConstPointer { addr } => {
            let int_ty = bridge
                .type_storage
                .convert(ValueType::Int(false, 64))
                .into_int_type();

            let ty = bridge
                .type_storage
                .convert(ValueType::Pointer(Box::new(ValueType::Unknown)))
                .into_pointer_type();

            let addr = int_ty.const_int(*addr as u64, false);

            let ptr = llvm_to_base!(bridge.builder.build_int_to_ptr(addr, ty, ""));

            Some(ptr.into())
        }

        Instruction::ConstString { str } => {
            let bytes = str.as_bytes();
            let byte_type = bridge
                .type_storage
                .convert(ValueType::Int(false, 8))
                .into_int_type();

            let arr_type = byte_type.array_type((bytes.len() + 1) as u32);

            let global = bridge.modules[&module.name].add_global(arr_type, None, "");

            global.set_linkage(Linkage::Private);
            global.set_constant(true);
            global.set_unnamed_addr(true);

            let mut vals: Vec<IntValue> = bytes
                .iter()
                .map(|b| byte_type.const_int(*b as u64, false))
                .collect();

            vals.push(byte_type.const_zero());

            global.set_initializer(&byte_type.const_array(&vals));

            Some(global.as_pointer_value().into())
        }

        Instruction::ConstStruct { ty, values } => {
            let ty = bridge.type_storage.convert(ty.clone()).into_struct_type();
            let mut vals = vec![];

            for value in values {
                vals.push(bridge.values[&value.inst_ind].clone().inner);
            }

            let val = ty.const_named_struct(&vals).into();

            Some(val)
        }

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

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

    return Ok(None);
}