wasker 0.2.2

Wasm compiler for running Wasm on your favorite kernel
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

//! Definition of numeric instructions.

use crate::environment::Environment;
use anyhow::Result;
use inkwell::values::BasicValue;

pub fn helper_code_gen_comparison(
    cond: inkwell::IntPredicate,
    environment: &mut Environment<'_, '_>,
) -> Result<()> {
    let v2 = environment
        .stack
        .pop()
        .expect("stack empty")
        .into_int_value();
    let v1 = environment
        .stack
        .pop()
        .expect("stack empty")
        .into_int_value();
    let cond = environment.builder.build_int_compare(cond, v1, v2, "");
    let result =
        environment
            .builder
            .build_int_z_extend(cond, environment.inkwell_types.i32_type, "");
    environment.stack.push(result.as_basic_value_enum());

    Ok(())
}

pub fn helper_code_gen_comparison_float(
    cond: inkwell::FloatPredicate,
    environment: &mut Environment<'_, '_>,
) -> Result<()> {
    let v2 = environment
        .stack
        .pop()
        .expect("stack empty")
        .into_float_value();
    let v1 = environment
        .stack
        .pop()
        .expect("stack empty")
        .into_float_value();
    let cond = environment.builder.build_float_compare(cond, v1, v2, "");
    let result =
        environment
            .builder
            .build_int_z_extend(cond, environment.inkwell_types.i32_type, "");
    environment.stack.push(result.as_basic_value_enum());

    Ok(())
}

pub fn gen_and(environment: &mut Environment<'_, '_>) -> Result<()> {
    let (v1, v2) = environment.pop2();
    let res = environment
        .builder
        .build_and(v1.into_int_value(), v2.into_int_value(), "");
    environment.stack.push(res.as_basic_value_enum());
    Ok(())
}

pub fn gen_or(environment: &mut Environment<'_, '_>) -> Result<()> {
    let (v1, v2) = environment.pop2();
    let res = environment
        .builder
        .build_or(v1.into_int_value(), v2.into_int_value(), "");
    environment.stack.push(res.as_basic_value_enum());
    Ok(())
}

pub fn gen_xor(environment: &mut Environment<'_, '_>) -> Result<()> {
    let (v1, v2) = environment.pop2();
    let res = environment
        .builder
        .build_xor(v1.into_int_value(), v2.into_int_value(), "");
    environment.stack.push(res.as_basic_value_enum());
    Ok(())
}

pub fn gen_shl(environment: &mut Environment<'_, '_>) -> Result<()> {
    let (v1, v2) = environment.pop2();
    let res = environment
        .builder
        .build_left_shift(v1.into_int_value(), v2.into_int_value(), "");
    environment.stack.push(res.as_basic_value_enum());
    Ok(())
}

pub fn gen_shr(environment: &mut Environment<'_, '_>, sign_extend: bool) -> Result<()> {
    let (v1, v2) = environment.pop2();
    let res = environment.builder.build_right_shift(
        v1.into_int_value(),
        v2.into_int_value(),
        sign_extend,
        "",
    );
    environment.stack.push(res.as_basic_value_enum());
    Ok(())
}

pub fn gen_rotl(environment: &mut Environment<'_, '_>, if_32bit: bool) -> Result<()> {
    let (v1, v2) = environment.pop2();
    let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
    let mask = if if_32bit {
        environment.inkwell_types.i32_type.const_int(31u64, false)
    } else {
        environment.inkwell_types.i64_type.const_int(63u64, false)
    };
    let v2 = environment.builder.build_and(v2, mask, "");
    let lhs = environment.builder.build_left_shift(v1, v2, "");

    let rhs = {
        let negv2 = environment.builder.build_int_neg(v2, "");
        let rhs = environment.builder.build_and(negv2, mask, "");
        environment.builder.build_right_shift(v1, rhs, false, "")
    };

    let res = environment.builder.build_or(lhs, rhs, "");
    environment.stack.push(res.as_basic_value_enum());
    Ok(())
}

pub fn gen_rotr(environment: &mut Environment<'_, '_>, if_32bit: bool) -> Result<()> {
    let (v1, v2) = environment.pop2();
    let (v1, v2) = (v1.into_int_value(), v2.into_int_value());
    let mask = if if_32bit {
        environment.inkwell_types.i32_type.const_int(31u64, false)
    } else {
        environment.inkwell_types.i64_type.const_int(63u64, false)
    };
    let v2 = environment.builder.build_and(v2, mask, "");
    let lhs = environment.builder.build_right_shift(v1, v2, false, "");

    let rhs = {
        let negv2 = environment.builder.build_int_neg(v2, "");
        let rhs = environment.builder.build_and(negv2, mask, "");
        environment.builder.build_left_shift(v1, rhs, "")
    };

    let res = environment.builder.build_or(lhs, rhs, "");
    environment.stack.push(res.as_basic_value_enum());
    Ok(())
}