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

//! Floating-point control and status.

use crate::system_register_access;
use tartan_bitfield::bitfield;
use tartan_c_enum::c_enum;


bitfield! {
    /// `FPCR`: Influences floating-point instruction execution.
    pub struct ControlRegister(u64) {
        /// `AHP`: Use an alternative format for half-precision floats when converting
        /// to/from other formats. Otherwise, use the IEEE half-precision format.
        [26] pub alternative_half_precision_format,
        /// `DN`: Always use the default encoding for NaN results. Otherwise, use the
        /// encoding from an input operand.
        [25] pub default_nan,
        /// `FZ`: When a result would be denormal, yield zero instead. Otherwise, use the
        /// IEEE 754 behavior.
        [24] pub flush_to_zero,
        /// `RMode`: The IEEE 754 rounding mode in use.
        [22..24] pub rounding_mode: u8 as RoundingMode,
        /// `FZ16`: Counterpart to [`flush_to_zero`](Self::flush_to_zero) for
        /// half-precision calculations.
        ///
        /// Requires `FEAT_FP16`.
        [19] pub flush_to_zero_half_precision,
        /// For each type of floating-point exception, defines whether the error will be
        /// trapped. If false, the corresponding flag in [`StatusRegister::exceptions`]
        /// will be set instead.
        [ 8..16] pub trapped_exceptions: u8 as Exceptions,
    }
}

system_register_access!(ControlRegister, "FPCR");


bitfield! {
    /// `FPSR`: Indicates non-trapped floating-point exceptions.
    pub struct StatusRegister(u64) {
        /// Indicates any non-trapped exceptions that have been detected since these flags
        /// were last reset.
        [ 0.. 8] pub exceptions: u8 as Exceptions,
    }
}

system_register_access!(StatusRegister, "FPSR");


c_enum! {
    /// Floating-point rounding mode, as defined by IEEE 754.
    pub enum RoundingMode(u8) {
        /// Round to the nearest number, with ties toward even numbers.
        Nearest,
        /// Round toward positive infinity.
        PlusInfinity,
        /// Round toward negative infinity.
        MinusInfinity,
        /// Round toward zero (truncate).
        Zero,
    }
}

bitfield! {
    /// Status/mask bits for each type of floating-point exception.
    pub struct Exceptions(u8) {
        /// `DN`: An operand was a denormal number.
        [7] denormal_input,
        /// `IX`: A result was rounded.
        [4] inexact,
        /// `UF`: A result was too small to be represented accurately.
        [3] underflow,
        /// `OF`: A result was too large to be represented accurately.
        [2] overflow,
        /// `DZ`: Attempted to divide a number by zero (other than zero or infinity, which
        /// raises an [`invalid_operation`] instead).
        [1] divide_by_zero,
        /// `IO`: Attempted a mathematically undefined operation, such as infinity minus
        /// infinity.
        [0] invalid_operation,
    }
}