mu_pi 7.0.0

Platform Initialization (PI) Specification definitions and support code in Rust.
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

//! Helper functions related to address manipulation.
//!
//! Portions derived from the x86_64 crate addr.rs file.
//!
//! ## License
//!
//! Copyright (C) Microsoft Corporation. All rights reserved.
//!
//! SPDX-License-Identifier: BSD-2-Clause-Patent
//!

/// Align address downwards.
///
/// Returns the greatest `x` with alignment `align` so that `x <= addr`.
///
/// Panics if the alignment is not a power of two.
#[inline]
pub const fn align_down(addr: u64, align: u64) -> u64 {
    assert!(align.is_power_of_two(), "`align` must be a power of two");
    addr & !(align - 1)
}

/// Align address upwards.
///
/// Returns the smallest `x` with alignment `align` so that `x >= addr`.
///
/// Panics if the alignment is not a power of two or if an overflow occurs.
#[inline]
pub const fn align_up(addr: u64, align: u64) -> u64 {
    assert!(align.is_power_of_two(), "`align` must be a power of two");
    let align_mask = align - 1;
    if addr & align_mask == 0 {
        addr // already aligned
    } else {
        // FIXME: Replace with .expect, once `Option::expect` is const.
        if let Some(aligned) = (addr | align_mask).checked_add(1) {
            aligned
        } else {
            panic!("attempt to add with overflow")
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::address_helper::{align_down, align_up};

    #[test]
    #[should_panic]
    fn align_down_align_panic() {
        // alignment is not a power of 2
        align_down(0, 0x0);
    }

    #[test]
    #[should_panic]
    fn align_up_align_panic() {
        // alignment is not a power of 2
        align_up(0, 0x0);
    }

    #[test]
    fn test_align_down() {
        // align 1
        assert_eq!(align_down(0, 1), 0);
        assert_eq!(align_down(1234, 1), 1234);
        assert_eq!(align_down(0xffff_ffff_ffff_ffff, 1), 0xffff_ffff_ffff_ffff);
        // align 2
        assert_eq!(align_down(0, 2), 0);
        assert_eq!(align_down(1234, 2), 1234);
        assert_eq!(align_down(0xffff_ffff_ffff_ffff, 2), 0xffff_ffff_ffff_fffe);
        // address 0
        assert_eq!(align_down(0, 128), 0);
        assert_eq!(align_down(0, 1), 0);
        assert_eq!(align_down(0, 2), 0);
        assert_eq!(align_down(0, 0x8000_0000_0000_0000), 0);

        // Validate alignment of (align > address) -> 0
        assert_eq!(align_down(0xFFFF, 0x1000_0000), 0);
    }

    #[test]
    fn test_align_up() {
        // align 1
        assert_eq!(align_up(0, 1), 0);
        assert_eq!(align_up(1234, 1), 1234);
        assert_eq!(align_up(0xffff_ffff_ffff_ffff, 1), 0xffff_ffff_ffff_ffff);
        // align 2
        assert_eq!(align_up(0, 2), 0);
        assert_eq!(align_up(1233, 2), 1234);
        assert_eq!(align_up(0xffff_ffff_ffff_fffe, 2), 0xffff_ffff_ffff_fffe);
        // address 0
        assert_eq!(align_up(0, 128), 0);
        assert_eq!(align_up(0, 1), 0);
        assert_eq!(align_up(0, 2), 0);
        assert_eq!(align_up(0, 0x8000_0000_0000_0000), 0);
    }

    #[test]
    #[should_panic]
    fn test_align_up_overflow() {
        // causes buffer overflow when checked_add(1) is called
        align_up(0xffff_ffff_ffff_ffff, 0x1_0000_0000_0000);
    }
}