jflib-rt 0.1.0

JFLib's runtime without std: allocator, memory intrinsics, program entry, panic handling
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

// fx -- scalar SSE float operations with exactly the semantics the assembly uses
// (cvttss2si, cvtss2si with round-half-even, sqrtss, minss, maxss), so float results
// are bit-identical to ASMLIB.  Rust never fuses a multiply and an add into an FMA.

use core::arch::x86_64::{_mm_cvtss_f32, _mm_cvtss_si32, _mm_cvttss_si32, _mm_set_ss, _mm_sqrt_ss};

/// cvttss2si: truncate towards zero (0x80000000 for NaN / out of range)
#[inline]
pub fn cvtt(x: f32) -> i32 {
    // SAFETY: SSE is part of the x86-64 baseline.
    unsafe { _mm_cvttss_si32(_mm_set_ss(x)) }
}

/// cvtss2si: round to nearest, ties to even (the default MXCSR mode)
#[inline]
pub fn cvt(x: f32) -> i32 {
    // SAFETY: SSE is part of the x86-64 baseline.
    unsafe { _mm_cvtss_si32(_mm_set_ss(x)) }
}

#[inline]
pub fn sqrt(x: f32) -> f32 {
    // SAFETY: SSE is part of the x86-64 baseline.
    unsafe { _mm_cvtss_f32(_mm_sqrt_ss(_mm_set_ss(x))) }
}

/// minss a, b: a < b ? a : b (b when unordered)
#[inline]
pub fn minss(a: f32, b: f32) -> f32 {
    if a < b { a } else { b }
}

/// maxss a, b: a > b ? a : b (b when unordered)
#[inline]
pub fn maxss(a: f32, b: f32) -> f32 {
    if a > b { a } else { b }
}

/// floor / ceil the way f_floor / f_ceil do it: truncate, then step if needed
#[inline]
pub fn floor_i(x: f32) -> i32 {
    let t = cvtt(x);
    if (t as f32) > x { t.wrapping_sub(1) } else { t }
}

#[inline]
pub fn ceil_i(x: f32) -> i32 {
    let t = cvtt(x);
    if (t as f32) < x { t.wrapping_add(1) } else { t }
}

/// round(x / 255) for x in 0..=65025: ((x + 128) * 257) >> 16 (pmulhuw), equal to
/// (x + 128 + ((x + 128) >> 8)) >> 8
#[inline]
pub fn div255(x: u32) -> u32 {
    debug_assert!(x < 1 << 24, "div255 is for x <= 65025");
    ((x + 128) * 257) >> 16
}

// ---- f64 (SSE2 sd / pd forms)

/// sqrtsd
#[inline]
pub fn sqrtd(x: f64) -> f64 {
    use core::arch::x86_64::{_mm_cvtsd_f64, _mm_set_sd, _mm_sqrt_pd};
    // SAFETY: SSE2 is part of the x86-64 baseline.
    unsafe { _mm_cvtsd_f64(_mm_sqrt_pd(_mm_set_sd(x))) }
}

/// maxsd a, b: a > b ? a : b (b when unordered)
#[inline]
pub fn maxsd(a: f64, b: f64) -> f64 {
    if a > b { a } else { b }
}

/// minsd a, b: a < b ? a : b (b when unordered)
#[inline]
pub fn minsd(a: f64, b: f64) -> f64 {
    if a < b { a } else { b }
}

/// cvttsd2si (32-bit): truncate towards zero (0x80000000 for NaN / out of range)
#[inline]
pub fn cvttd(x: f64) -> i32 {
    use core::arch::x86_64::{_mm_cvttsd_si32, _mm_set_sd};
    // SAFETY: SSE2 is part of the x86-64 baseline.
    unsafe { _mm_cvttsd_si32(_mm_set_sd(x)) }
}

/// cvtsd2si (32-bit): round to nearest even (0x80000000 for NaN / out of range)
#[inline]
pub fn cvtd(x: f64) -> i32 {
    use core::arch::x86_64::{_mm_cvtsd_si32, _mm_set_sd};
    // SAFETY: SSE2 is part of the x86-64 baseline.
    unsafe { _mm_cvtsd_si32(_mm_set_sd(x)) }
}

/// cvtsd2si (64-bit): round to nearest even (i64::MIN for NaN / out of range)
#[inline]
pub fn cvtd64(x: f64) -> i64 {
    use core::arch::x86_64::{_mm_cvtsd_si64, _mm_set_sd};
    // SAFETY: SSE2 is part of the x86-64 baseline.
    unsafe { _mm_cvtsd_si64(_mm_set_sd(x)) }
}

/// cvttsd2si (64-bit): truncate (i64::MIN for NaN / out of range)
#[inline]
pub fn cvttd64(x: f64) -> i64 {
    use core::arch::x86_64::{_mm_cvttsd_si64, _mm_set_sd};
    // SAFETY: SSE2 is part of the x86-64 baseline.
    unsafe { _mm_cvttsd_si64(_mm_set_sd(x)) }
}