starina_utils/
alignment.rs

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
/// Aligns a value down to the nearest multiple of `align`.
///
/// `align` must be a power of two.
///
/// # Example
///
/// ```
/// use starina_utils::alignment::align_down;
///
/// assert_eq!(align_down(0x0000, 0x1000), 0x0000);
/// assert_eq!(align_down(0x0001, 0x1000), 0x0000);
/// assert_eq!(align_down(0x1000, 0x1000), 0x1000);
/// assert_eq!(align_down(0x1001, 0x1000), 0x1000);
/// assert_eq!(align_down(0x2000, 0x1000), 0x2000);
/// ```
pub const fn align_down(value: usize, align: usize) -> usize {
    debug_assert!(align.is_power_of_two());

    (value) & !(align - 1)
}

/// Aligns a value up to the nearest multiple of `align`.
///
/// `align` must be a power of two.
///
/// # Example
///
/// ```
/// use starina_utils::alignment::align_up;
///
/// assert_eq!(align_up(0x0000, 0x1000), 0x0000);
/// assert_eq!(align_up(0x0001, 0x1000), 0x1000);
/// assert_eq!(align_up(0x1000, 0x1000), 0x1000);
/// assert_eq!(align_up(0x1001, 0x1000), 0x2000);
/// assert_eq!(align_up(0x2000, 0x1000), 0x2000);
/// ```
pub const fn align_up(value: usize, align: usize) -> usize {
    debug_assert!(align.is_power_of_two());

    align_down(value + align - 1, align)
}

/// Returns `true` if `value` is aligned to `align`.
///
/// `align` must be a power of two.
///
/// # Example
///
/// ```
/// use starina_utils::alignment::is_aligned;
///
/// assert_eq!(is_aligned(0x0000, 0x1000), true);
/// assert_eq!(is_aligned(0x0001, 0x1000), false);
/// assert_eq!(is_aligned(0x1000, 0x1000), true);
/// assert_eq!(is_aligned(0x1001, 0x1000), false);
/// assert_eq!(is_aligned(0x2000, 0x1000), true);
/// ```
pub const fn is_aligned(value: usize, align: usize) -> bool {
    debug_assert!(align.is_power_of_two());

    value & (align - 1) == 0
}