xqvm 0.2.0

X-Quadratic Virtual Machine — bytecode interpreter for the XQuad Toolchain
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

// Copyright (C) 2026 Postquant Labs Incorporated
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.
//
// SPDX-License-Identifier: AGPL-3.0-or-later

use core::hash::Hash;

use crate::dataflow::cfg::Cfg;

mod sealed {
    pub trait Sealed {}
}

/// Zero-sized marker for a forward data-flow analysis.
///
/// The boundary is the CFG entry; facts flow from predecessors into each node.
pub struct Forward;

/// Zero-sized marker for a backward data-flow analysis.
///
/// The boundary is the CFG exit; facts flow from successors into each node.
pub struct Backward;

impl sealed::Sealed for Forward {}
impl sealed::Sealed for Backward {}

/// Sealed trait that parameterises the solver over flow direction.
///
/// Implementors are [`Forward`] and [`Backward`].  All methods are generic
/// over the node type `N` so that a single `impl` handles any `Cfg<N>`.
///
/// This trait is sealed: no external implementations are allowed.
pub trait Direction: sealed::Sealed {
    /// The node that receives the analysis boundary value.
    ///
    /// For [`Forward`] this is the CFG entry; for [`Backward`] the CFG exit.
    fn boundary_node<N: Eq + Hash + Clone>(cfg: &Cfg<N>) -> &N;

    /// Nodes whose outgoing state feeds into `node` under this direction.
    ///
    /// For [`Forward`] these are the predecessors; for [`Backward`] the successors.
    fn input_edges<'g, N: Eq + Hash + Clone>(cfg: &'g Cfg<N>, node: &N) -> &'g [N];

    /// Nodes that must be re-evaluated when `node`'s state changes.
    ///
    /// For [`Forward`] these are the successors; for [`Backward`] the predecessors.
    fn output_edges<'g, N: Eq + Hash + Clone>(cfg: &'g Cfg<N>, node: &N) -> &'g [N];
}

impl Direction for Forward {
    fn boundary_node<N: Eq + Hash + Clone>(cfg: &Cfg<N>) -> &N {
        cfg.entry()
    }

    fn input_edges<'g, N: Eq + Hash + Clone>(cfg: &'g Cfg<N>, node: &N) -> &'g [N] {
        cfg.predecessors(node)
    }

    fn output_edges<'g, N: Eq + Hash + Clone>(cfg: &'g Cfg<N>, node: &N) -> &'g [N] {
        cfg.successors(node)
    }
}

impl Direction for Backward {
    fn boundary_node<N: Eq + Hash + Clone>(cfg: &Cfg<N>) -> &N {
        cfg.exit()
    }

    fn input_edges<'g, N: Eq + Hash + Clone>(cfg: &'g Cfg<N>, node: &N) -> &'g [N] {
        cfg.successors(node)
    }

    fn output_edges<'g, N: Eq + Hash + Clone>(cfg: &'g Cfg<N>, node: &N) -> &'g [N] {
        cfg.predecessors(node)
    }
}