haskelujah-runtime 0.1.1

STG evaluator and runtime services for the Haskelujah compiler
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

// For God so loved the world that he gave his only begotten Son, that whoever
// believes in him should not perish but have eternal life. — John 3:16

//! # Garbage collector
//!
//! Re-exports the backend-agnostic GC primitives from `haskelujah-rts-chirho`
//! (configuration, statistics, mark-sweep state, value root extraction).
//!
//! Adds the interpreter-specific `extract_roots_from_stack_chirho` which
//! depends on `FrameChirho` — a type that only exists in this crate.

// Re-export shared GC types from the RTS crate.
pub use haskelujah_rts_chirho::gc_chirho::{
    GcConfigChirho, GcStateChirho, GcStatsChirho, extract_roots_from_values_chirho,
};

use crate::stack_chirho::FrameChirho;
use crate::value_chirho::{HeapAddrChirho, ValueChirho};

// ---------------------------------------------------------------------------
// Stack root extraction (interpreter-specific)
// ---------------------------------------------------------------------------

/// Extract all heap addresses from the stack frames.
pub fn extract_roots_from_stack_chirho(frames_chirho: &[FrameChirho]) -> Vec<HeapAddrChirho> {
    let mut roots_chirho = Vec::new();
    for frame_chirho in frames_chirho {
        match frame_chirho {
            FrameChirho::ApplyChirho { args_chirho } => {
                for val_chirho in args_chirho {
                    if let ValueChirho::HeapPtrChirho(addr_chirho) = val_chirho {
                        roots_chirho.push(*addr_chirho);
                    }
                }
            }
            FrameChirho::UpdateChirho { thunk_addr_chirho } => {
                roots_chirho.push(*thunk_addr_chirho);
            }
            FrameChirho::CaseChirho {
                saved_arg_regs_chirho,
                ..
            } => {
                for val_chirho in saved_arg_regs_chirho {
                    if let ValueChirho::HeapPtrChirho(addr_chirho) = val_chirho {
                        roots_chirho.push(*addr_chirho);
                    }
                }
            }
            FrameChirho::CaseLitChirho {
                alt_entries_chirho,
                saved_arg_regs_chirho,
                ..
            } => {
                for (val_chirho, _) in alt_entries_chirho {
                    if let ValueChirho::HeapPtrChirho(addr_chirho) = val_chirho {
                        roots_chirho.push(*addr_chirho);
                    }
                }
                for val_chirho in saved_arg_regs_chirho {
                    if let ValueChirho::HeapPtrChirho(addr_chirho) = val_chirho {
                        roots_chirho.push(*addr_chirho);
                    }
                }
            }
            FrameChirho::PrimOpChirho {
                args_so_far_chirho,
                pending_args_chirho,
                ..
            } => {
                for val_chirho in args_so_far_chirho.iter().chain(pending_args_chirho.iter()) {
                    if let ValueChirho::HeapPtrChirho(addr_chirho) = val_chirho {
                        roots_chirho.push(*addr_chirho);
                    }
                }
            }
            FrameChirho::CatchChirho {
                handler_addr_chirho,
                saved_arg_regs_chirho,
            } => {
                roots_chirho.push(*handler_addr_chirho);
                for val_chirho in saved_arg_regs_chirho {
                    if let ValueChirho::HeapPtrChirho(addr_chirho) = val_chirho {
                        roots_chirho.push(*addr_chirho);
                    }
                }
            }
            FrameChirho::TryFrameChirho {
                saved_arg_regs_chirho,
            } => {
                for val_chirho in saved_arg_regs_chirho {
                    if let ValueChirho::HeapPtrChirho(addr_chirho) = val_chirho {
                        roots_chirho.push(*addr_chirho);
                    }
                }
            }
        }
    }
    roots_chirho
}

// ---------------------------------------------------------------------------
// Tests
// ---------------------------------------------------------------------------

#[cfg(test)]
mod tests_chirho {
    use super::*;

    #[test]
    fn extract_roots_from_stack_chirho() {
        let frames_chirho = vec![
            FrameChirho::ApplyChirho {
                args_chirho: vec![
                    ValueChirho::HeapPtrChirho(HeapAddrChirho(1)),
                    ValueChirho::IntChirho(99),
                ],
            },
            FrameChirho::UpdateChirho {
                thunk_addr_chirho: HeapAddrChirho(7),
            },
            FrameChirho::CaseChirho {
                alt_entries_chirho: vec![],
                default_entry_chirho: None,
                saved_arg_regs_chirho: vec![],
            },
        ];
        let roots_chirho = super::extract_roots_from_stack_chirho(&frames_chirho);
        assert_eq!(roots_chirho, vec![HeapAddrChirho(1), HeapAddrChirho(7)]);
    }
}