rvsim 0.2.2

A RISC-V simulator implementing RV32G[C].
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216

//! Berkeley SoftFloat bindings.
//!
//! These are partial bindings, and only part of the SoftFloat package is actually linked into the
//! library. Some of the names have been altered to be more in line with Rust naming.

// This file is modified from bindings generated by `bindgen` based on
// `softfloat.h`. It contains only the parts we use.

use std::mem::transmute;

/// Round to nearest, ties to even.
pub const ROUND_NEAR_EVEN: u8 = 0;
/// Round towards 0.
pub const ROUND_MIN_MAG: u8 = 1;
/// Round towards -∞.
pub const ROUND_MIN: u8 = 2;
/// Round towards +∞.
pub const ROUND_MAX: u8 = 3;
/// Round to nearest, ties away from 0.
pub const ROUND_NEAR_MAXMAG: u8 = 4;

/// Inexact result exception.
pub const FLAG_INEXACT: u8 = 1;
/// Underflow exception.
pub const FLAG_UNDERFLOW: u8 = 2;
/// Overflow exception.
pub const FLAG_OVERFLOW: u8 = 4;
/// Result is infinity (division by zero).
pub const FLAG_INFINITE: u8 = 8;
/// Invalid operation (result is NaN).
pub const FLAG_INVALID: u8 = 16;

/// A single-precision soft-float. Internally represented as `u32`.
///
/// With the `serialize` crate feature, this structure is serializable using Serde.
#[repr(C)]
#[derive(Clone,Copy,Debug)]
#[cfg_attr(feature = "serialize", derive(Serialize,Deserialize))]
pub struct Sf32(pub u32);

impl Sf32 {
    /// The canonical NaN value.
    pub const NAN: Sf32 = Sf32(0x7fc0_0000);

    /// Negate the value / flip the sign bit.
    pub fn negate(self) -> Sf32 {
        Sf32(self.0 ^ 0x8000_0000)
    }
}

impl From<f32> for Sf32 {
    /// Conversion that simply transmutes the value.
    fn from(x: f32) -> Sf32 {
        unsafe { transmute(x) }
    }
}

impl From<Sf32> for f32 {
    /// Conversion that simply transmutes the value.
    fn from(x: Sf32) -> f32 {
        unsafe { transmute(x) }
    }
}

/// A double-precision soft-float. Internally represented as `u64`.
///
/// With the `serialize` crate feature, this structure is serializable using Serde.
#[repr(C)]
#[derive(Clone,Copy,Debug)]
#[cfg_attr(feature = "serialize", derive(Serialize,Deserialize))]
pub struct Sf64(pub u64);

impl Sf64 {
    /// The canonical NaN value.
    pub const NAN: Sf64 = Sf64(0x7ff8_0000_0000_0000);

    /// Negate the value / flip the sign bit.
    pub fn negate(self) -> Sf64 {
        Sf64(self.0 ^ 0x8000_0000_0000_0000)
    }
}

impl From<f64> for Sf64 {
    /// Conversion that simply transmutes the value.
    fn from(x: f64) -> Sf64 {
        unsafe { transmute(x) }
    }
}

impl From<Sf64> for f64 {
    /// Conversion that simply transmutes the value.
    fn from(x: Sf64) -> f64 {
        unsafe { transmute(x) }
    }
}

impl From<Sf32> for Sf64 {
    /// Conversion that adds NaN-boxing.
    fn from(x: Sf32) -> Sf64 {
        Sf64(0xffff_ffff_0000_0000 | u64::from(x.0))
    }
}

impl From<Sf64> for Sf32 {
    /// Conversion that discards the upper-bits, which are assumed to be NaN-boxing.
    fn from(x: Sf64) -> Sf32 {
        Sf32(x.0 as u32)
    }
}

impl From<f32> for Sf64 {
    /// Conversion that transmutes the value, then adds NaN-boxing.
    fn from(x: f32) -> Sf64 {
        Sf32::from(x).into()
    }
}

impl From<Sf64> for f32 {
    /// Conversion that discards the upper-bits, which are assumed to be NaN-boxing, then
    /// transmutes the value.
    fn from(x: Sf64) -> f32 {
        Sf32::from(x).into()
    }
}

extern "C" {
    /// Get the exception flags from thread-local storage.
    #[link_name = "softfloat_getFlags"]
    pub fn get_flags() -> u8;
    /// Set the exception flags.
    #[link_name = "softfloat_setFlags"]
    pub fn set_flags(arg1: u8);
    /// Add to the exception flags.
    #[link_name = "softfloat_raiseFlags"]
    pub fn raise_flags(arg1: u8);

    /// Get the current rounding mode from thread-local storage.
    #[link_name = "softfloat_getRoundingMode"]
    pub fn get_rounding_mode() -> u8;
    /// Set the rounding mode.
    #[link_name = "softfloat_setRoundingMode"]
    pub fn set_rounding_mode(arg1: u8);

    /// Convert a `u32` to a single-precision value.
    #[link_name = "ui32_to_f32"]
    pub fn u32_to_f32(arg1: u32) -> Sf32;
    /// Convert a `u32` to a double-precision value.
    #[link_name = "ui32_to_f64"]
    pub fn u32_to_f64(arg1: u32) -> Sf64;
    /// Convert an `i32` to a single-precision value.
    pub fn i32_to_f32(arg1: i32) -> Sf32;
    /// Convert an `i32` to a double-precision value.
    pub fn i32_to_f64(arg1: i32) -> Sf64;

    /// Convert a single-precision value to a `u32`.
    #[link_name = "f32_to_ui32"]
    pub fn f32_to_u32(arg1: Sf32, arg2: u8, arg3: bool) -> u32;
    /// Convert a single-precision value to an `i32`.
    pub fn f32_to_i32(arg1: Sf32, arg2: u8, arg3: bool) -> i32;
    /// Convert a single-precision value to a double-precision value.
    pub fn f32_to_f64(arg1: Sf32) -> Sf64;
    /// Addition with single-precision values.
    pub fn f32_add(arg1: Sf32, arg2: Sf32) -> Sf32;
    /// Subtraction with single-precision values.
    pub fn f32_sub(arg1: Sf32, arg2: Sf32) -> Sf32;
    /// Multiplication with single-precision values.
    pub fn f32_mul(arg1: Sf32, arg2: Sf32) -> Sf32;
    /// Fused multiplication and addition with single-precision values.
    pub fn f32_mulAdd(arg1: Sf32, arg2: Sf32, arg3: Sf32) -> Sf32;
    /// Division with single-precision values.
    pub fn f32_div(arg1: Sf32, arg2: Sf32) -> Sf32;
    /// Modulus / remainder with single-precision values.
    pub fn f32_rem(arg1: Sf32, arg2: Sf32) -> Sf32;
    /// Square root of a single-precision value.
    pub fn f32_sqrt(arg1: Sf32) -> Sf32;
    /// Test equality with single-precision values.
    pub fn f32_eq(arg1: Sf32, arg2: Sf32) -> bool;
    /// Test less-than-or-equal with single-precision values.
    pub fn f32_le(arg1: Sf32, arg2: Sf32) -> bool;
    /// Test less-than with single-precision values.
    pub fn f32_lt(arg1: Sf32, arg2: Sf32) -> bool;
    /// Whether the single-precision value is a signalling NaN.
    #[link_name = "f32_isSignalingNaN"]
    pub fn f32_is_signaling_nan(arg1: Sf32) -> bool;

    /// Convert a double-precision value to a `u32`.
    #[link_name = "f64_to_ui32"]
    pub fn f64_to_u32(arg1: Sf64, arg2: u8, arg3: bool) -> u32;
    /// Convert a double-precision value to an `i32`.
    pub fn f64_to_i32(arg1: Sf64, arg2: u8, arg3: bool) -> i32;
    /// Convert a double-precision value to a single-precision value.
    pub fn f64_to_f32(arg1: Sf64) -> Sf32;
    /// Addition with double-precision values.
    pub fn f64_add(arg1: Sf64, arg2: Sf64) -> Sf64;
    /// Subtraction with double-precision values.
    pub fn f64_sub(arg1: Sf64, arg2: Sf64) -> Sf64;
    /// Multiplication with double-precision values.
    pub fn f64_mul(arg1: Sf64, arg2: Sf64) -> Sf64;
    /// Fused multiplication and addition with double-precision values.
    pub fn f64_mulAdd(arg1: Sf64, arg2: Sf64, arg3: Sf64) -> Sf64;
    /// Division with double-precision values.
    pub fn f64_div(arg1: Sf64, arg2: Sf64) -> Sf64;
    /// Modulus / remainder with double-precision values.
    pub fn f64_rem(arg1: Sf64, arg2: Sf64) -> Sf64;
    /// Square root of a double-precision value.
    pub fn f64_sqrt(arg1: Sf64) -> Sf64;
    /// Test equality with double-precision values.
    pub fn f64_eq(arg1: Sf64, arg2: Sf64) -> bool;
    /// Test less-than-or-equal with double-precision values.
    pub fn f64_le(arg1: Sf64, arg2: Sf64) -> bool;
    /// Test less-than with double-precision values.
    pub fn f64_lt(arg1: Sf64, arg2: Sf64) -> bool;
    /// Whether the double-precision value is a signalling NaN.
    #[link_name = "f64_isSignalingNaN"]
    pub fn f64_is_signaling_nan(arg1: Sf64) -> bool;
}