rvsdg 0.2.0

Type-safe standalone implementation of the RVSDG IR with automatic Phi transformation
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

//! Raw ID types mapping to vectors in [`crate::Context`]

use std::fmt;
use std::marker::PhantomData;

use cranelift_entity::entity_impl;

#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub struct AnyNode(u32);
entity_impl!(AnyNode, "node");

#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub struct Region(u32);
entity_impl!(Region, "region");

#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub struct Argument(u32);
entity_impl!(Argument, "a");

#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub struct Result(u32);
entity_impl!(Result, "r");

#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub struct Input(pub(crate) u32);
entity_impl!(Input, "i");

#[derive(Clone, Copy, PartialEq, Eq, Hash)]
pub struct Output(pub(crate) u32);
entity_impl!(Output, "o");

#[derive(Debug)]
pub struct Node<K> {
    pub id: AnyNode,
    _kind: PhantomData<K>,
}

impl<K> Clone for Node<K> {
    fn clone(&self) -> Self {
        *self
    }
}
impl<K> Copy for Node<K> {}

impl<K> PartialEq for Node<K> {
    fn eq(&self, other: &Self) -> bool {
        self.id == other.id
    }
}

impl<K> std::hash::Hash for Node<K> {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        self.id.hash(state);
    }
}

impl<K> Eq for Node<K> {}

impl<K> Node<K> {
    pub(super) fn new(id: AnyNode) -> Self {
        Self {
            id,
            _kind: PhantomData,
        }
    }
}

impl From<AnyNode> for Node<AnyNode> {
    fn from(id: AnyNode) -> Self {
        Node::new(id)
    }
}

impl<K> fmt::Display for Node<K> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        self.id.fmt(f)
    }
}

impl Region {
    pub fn argument(self, id: Argument) -> super::Argument {
        super::Argument { region: self, id }
    }

    pub fn result(self, id: Result) -> super::Result {
        super::Result { region: self, id }
    }
}

impl<K> Node<K> {
    pub fn input(self, id: Input) -> super::Input<K> {
        super::Input { id, node: self }
    }

    pub fn output(self, id: Output) -> super::Output<K> {
        super::Output { id, node: self }
    }
}