mijit 0.2.4

Experimental JIT compiler generator
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

use super::{Dep};
use super::code::{Register, Variable, Precision, UnaryOp, BinaryOp, Width, Address, Action};

/// Annotates a [`Node`] of a [`Dataflow`] graph.
///
/// [`Node`]: super::Node
/// [`Dataflow`]: super::Dataflow
#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
#[repr(u8)]
pub enum Op {
    /// Represents a control-flow decision.
    Guard,
    /// A no-op used on entry to a Dataflow graph.
    Input,
    Constant(i64),
    Unary(Precision, UnaryOp),
    Binary(Precision, BinaryOp),
    Load(i32, Width),
    Store(i32, Width),
    Send,
    Debug,
}

impl Op {
    /// Returns the [`Dep`]s of the operands of a [`Node`] annotated with this
    /// `Op`.
    ///
    /// [`Node`]: super::Node
    pub fn deps(self) -> &'static [Dep] {
        match self {
            Op::Guard => &[Dep::GUARD, Dep::VALUE],
            Op::Input => &[],
            Op::Constant(_) => &[],
            Op::Unary(_, _) => &[Dep::VALUE],
            Op::Binary(_, _) => &[Dep::VALUE, Dep::VALUE],
            Op::Load(_, _) => &[Dep::GUARD, Dep::LOAD],
            Op::Store(_, _) => &[Dep::GUARD, Dep::VALUE, Dep::STORE],
            Op::Send => &[Dep::VALUE, Dep::SEND],
            Op::Debug => &[Dep::GUARD, Dep::VALUE],
        }
    }

    /// Aggregates this [`Op`] with the specified outputs and inputs to make an
    /// [`Action`].
    /// Panics if the `Op` is a `Guard`.
    pub fn to_action(self, out: Option<Register>, ins: &[Variable]) -> Action {
        match self {
            Op::Guard => panic!("Cannot convert a guard to an action"),
            Op::Input => panic!("Cannot convert an input to an action"),
            Op::Constant(c) => {
                assert_eq!(ins.len(), 0);
                Action::Constant(Precision::P64, out.unwrap(), c)
            },
            Op::Unary(prec, op) => {
                assert_eq!(ins.len(), 1);
                Action::Unary(op, prec, out.unwrap(), ins[0])
            },
            Op::Binary(prec, op) => {
                assert_eq!(ins.len(), 2);
                Action::Binary(op, prec, out.unwrap(), ins[0], ins[1])
            },
            Op::Load(offset, width) => {
                assert_eq!(ins.len(), 1);
                Action::Load(out.unwrap(), Address {base: ins[0], offset, width})
            },
            Op::Store(offset, width) => {
                assert_eq!(ins.len(), 2);
                Action::Store(out.unwrap(), ins[0], Address {base: ins[1], offset, width})
            },
            Op::Send => {
                assert_eq!(ins.len(), 2);
                Action::Send(out.unwrap(), ins[0], ins[1])
            },
            Op::Debug => {
                assert!(out.is_none());
                assert_eq!(ins.len(), 1);
                Action::Debug(ins[0])
            },
        }
    }
}