edlc_codegen_cranelift 0.2.17

Cranelift codegen backend for the EDL 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

/*
 * EDLc, a compiler for the EDL programming language.
 * Copyright (C) 2026  Adrian Paskert
 *
 * 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 <http://www.gnu.org/licenses/>.
 */
use crate::executor::{CatchUnwind, CraneliftJIT, FnReport, JITBencher, TestReport};
use edlc_core::prelude::edl_type::EdlTypeId;

pub(crate) struct UnitTest {
    pub(crate) id: EdlTypeId,
    pub(crate) stub: extern "C" fn(),
    pub(crate) setup: Vec<extern "C" fn()>,
    pub(crate) teardown: Vec<extern "C" fn()>,
}

/// A test executor can be used to run tests.
/// It is essentially a wrapper around pre-identified unit tests in a module.
/// After the creation of the [TestExec], all test entry points will have been created and
/// compiled to executable `extern "C" fn()` function stubs.
pub struct TestExec {
    pub(crate) stubs: Vec<UnitTest>,
}

impl TestExec {
    pub fn run<R: 'static>(&self, compiler: &CraneliftJIT<R>) -> Result<TestReport, anyhow::Error> {
        let mut report = TestReport::default();
        'outer: for UnitTest { id, stub, setup, teardown } in self.stubs.iter() {
            for setup_fn in setup.into_iter() {
                if let Err(err) = compiler.catch_unwind(*setup_fn, ()) {
                    report.insert(*id, FnReport::SetupErr(err));
                    continue 'outer;
                }
            }
            match compiler.catch_unwind(*stub, ()) {
                Ok(()) => (),
                Err(err) => {
                    report.insert(*id, FnReport::Err(err));
                    continue 'outer;
                },
            }
            for teardown_fn in teardown.into_iter() {
                if let Err(err) = compiler.catch_unwind(*teardown_fn, ()) {
                    report.insert(*id, FnReport::TeardownError(err));
                    continue 'outer;
                }
            }
            report.insert(*id, FnReport::Ok);
        }
        Ok(report)
    }

    pub fn bench<R: 'static>(
        &self,
        bencher: &mut impl JITBencher<R>,
        compiler: &CraneliftJIT<R>,
    ) -> Result<TestReport, anyhow::Error> {
        let mut report = TestReport::default();
        for UnitTest { id, stub, setup, teardown } in self.stubs.iter() {
            let full_name = compiler.compiler.phase.types
                .get_fn_qualifier(*id)?
                .as_ref()
                .unwrap();
            let n = bencher.start_bench(full_name, compiler);
            let mut ok = true;
            'outer: for _ in 0..n {
                for setup_fn in setup.iter() {
                    if let Err(err) = compiler.catch_unwind(*setup_fn, ()) {
                        report.insert(*id, FnReport::SetupErr(err));
                        ok = false;
                        break 'outer;
                    }
                }
                bencher.start_round(compiler);
                let res = compiler.catch_unwind(*stub, ());
                bencher.stop_round(compiler);
                if let Err(err) = res {
                    report.insert(*id, FnReport::Err(err));
                    ok = false;
                    break 'outer;
                }

                for teardown_fn in teardown.iter() {
                    if let Err(err) = compiler.catch_unwind(*teardown_fn, ()) {
                        report.insert(*id, FnReport::TeardownError(err));
                        ok = false;
                        break 'outer;
                    }
                }
            }
            if ok {
                report.insert(*id, FnReport::Ok);
            }
            bencher.end_bench(compiler);
        }
        Ok(report)
    }
}