daku 0.5.0

Interface to the Daku API
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

//! Portal for getting information about the CPU.

use std::mem::MaybeUninit;

use crate::{ffi, types::TextMut};

/// CPU architecture list.
#[non_exhaustive]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum Arch {
    /// Web Assembly
    Wasm = 0,
    /// RISC-V
    RiscV = 1,
    /// ARM
    Arm = 2,
    /// MIPS
    Mips = 3,
    /// X86 AMD/Intel
    X86 = 4,
}

/// Get the CPU architecture of the underlying system.
pub async fn arch() -> Arch {
    let ready = ffi::allocate();
    let mut out = MaybeUninit::<u32>::uninit();
    let future = unsafe {
        ffi::request_future(ffi::Command {
            portal: ffi::Portal::CpuInfo,
            ready,
            command: 0,
            data: out.as_mut_ptr().cast(),
        })
    };
    future.await;
    match unsafe { out.assume_init() } {
        0 => Arch::Wasm,
        1 => Arch::RiscV,
        2 => Arch::Arm,
        3 => Arch::Mips,
        4 => Arch::X86,
        _ => Arch::Wasm,
    }
}

/// CPU pointer/reference/word width
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum Width {
    /// 16-bit or lower
    Cpu16 = 0,
    /// 32-bit
    Cpu32 = 1,
    /// 64-bit
    Cpu64 = 2,
    /// 128-bit
    Cpu128 = 3,
}

/// Get the CPU pointer/reference/word width
pub async fn width() -> Width {
    let ready = ffi::allocate();
    let mut out = MaybeUninit::<u32>::uninit();
    let future = unsafe {
        ffi::request_future(ffi::Command {
            portal: ffi::Portal::CpuInfo,
            ready,
            command: 1,
            data: out.as_mut_ptr().cast(),
        })
    };
    future.await;
    match unsafe { out.assume_init() } {
        0 => Width::Cpu16,
        1 => Width::Cpu32,
        2 => Width::Cpu64,
        3 => Width::Cpu128,
        _ => Width::Cpu32,
    }
}

/// Get the CPU extensions (contents may vary, so shoudn't be relied on).
pub async fn extensions() -> String {
    // Get required length
    let ready = ffi::allocate();
    let mut out = TextMut {
        size: 0,
        data: std::ptr::null_mut(),
    };
    let future = unsafe {
        ffi::request_future(ffi::Command {
            portal: ffi::Portal::CpuInfo,
            ready,
            command: 2,
            data: <*mut TextMut>::cast(&mut out),
        })
    };
    future.await;
    // Get the string
    let ready = ffi::allocate();
    let mut string = String::with_capacity(out.size);
    let mut out = TextMut {
        size: string.capacity(),
        data: string.as_mut_ptr(),
    };
    let future = unsafe {
        ffi::request_future(ffi::Command {
            portal: ffi::Portal::CpuInfo,
            ready,
            command: 2,
            data: <*mut TextMut>::cast(&mut out),
        })
    };
    future.await;
    string
}