//! x86_64 的 `xsave` 和 `xsaveopt` 目标特性的内部函数

#![allow(clippy::module_name_repetitions)]

#[cfg(test)]
use stdarch_test::assert_instr;

#[allow(improper_ctypes)]
extern "C" {
    #[link_name = "llvm.x86.xsave64"]
    fn xsave64(p: *mut u8, hi: u32, lo: u32);
    #[link_name = "llvm.x86.xrstor64"]
    fn xrstor64(p: *const u8, hi: u32, lo: u32);
    #[link_name = "llvm.x86.xsaveopt64"]
    fn xsaveopt64(p: *mut u8, hi: u32, lo: u32);
    #[link_name = "llvm.x86.xsavec64"]
    fn xsavec64(p: *mut u8, hi: u32, lo: u32);
    #[link_name = "llvm.x86.xsaves64"]
    fn xsaves64(p: *mut u8, hi: u32, lo: u32);
    #[link_name = "llvm.x86.xrstors64"]
    fn xrstors64(p: *const u8, hi: u32, lo: u32);
}

/// 将已启用的处理器状态全部或部分保存到 `mem_addr` 的内存中。
///
/// 根据 `save_mask` 和 XCR0 中的 `[62:0]` 位保存状态。
/// `mem_addr` 必须在 64 字节边界上对齐。
///
/// XSAVE 区域的格式在英特尔 ® 64 和 IA-32 架构软件开发人员手册卷的 13.4 节 `XSAVE 区域` 中有详细说明 1.
///
///
/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_xsave64)
///
#[inline]
#[target_feature(enable = "xsave")]
#[cfg_attr(test, assert_instr(xsave64))]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _xsave64(mem_addr: *mut u8, save_mask: u64) {
    xsave64(mem_addr, (save_mask >> 32) as u32, save_mask as u32);
}

/// 使用 `mem_addr` 内存中存储的状态信息执行已启用处理器状态的全部或部分还原。
///
///
/// 根据 `rs_mask`，`XCR0` 和 `mem_addr.HEADER.XSTATE_BV` 中的 `[62:0]` 位恢复状态。
/// `mem_addr` 必须在 64 字节边界上对齐。
///
/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_xrstor64)
///
#[inline]
#[target_feature(enable = "xsave")]
#[cfg_attr(test, assert_instr(xrstor64))]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _xrstor64(mem_addr: *const u8, rs_mask: u64) {
    xrstor64(mem_addr, (rs_mask >> 32) as u32, rs_mask as u32);
}

/// 将已启用的处理器状态全部或部分保存到 `mem_addr` 的内存中。
///
/// 根据 `save_mask` 和 `XCR0` 中的 `[62:0]` 位保存状态。
/// `mem_addr` 必须在 64 字节边界上对齐。硬件可以优化数据的保存方式。
/// 该指令的性能将等于或优于使用 `XSAVE64` 指令。
///
/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_xsaveopt64)
///
///
#[inline]
#[target_feature(enable = "xsave,xsaveopt")]
#[cfg_attr(test, assert_instr(xsaveopt64))]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _xsaveopt64(mem_addr: *mut u8, save_mask: u64) {
    xsaveopt64(mem_addr, (save_mask >> 32) as u32, save_mask as u32);
}

/// 将已启用的处理器状态全部或部分保存到 `mem_addr` 的内存中。
///
/// `xsavec` 与 `xsave` 的不同之处在于它使用压缩并且它可能使用初始化优化。
/// 根据 `save_mask` 和 `XCR0` 中的 `[62:0]` 位保存状态。
/// `mem_addr` 必须在 64 字节边界上对齐。
///
/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_xsavec64)
///
#[inline]
#[target_feature(enable = "xsave,xsavec")]
#[cfg_attr(test, assert_instr(xsavec64))]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _xsavec64(mem_addr: *mut u8, save_mask: u64) {
    xsavec64(mem_addr, (save_mask >> 32) as u32, save_mask as u32);
}

/// 在 `mem_addr` 处将启用的处理器状态全部或部分保存到内存
///
/// `xsaves` 与 xsave 的不同之处在于它可以保存与 `IA32_XSS` `MSR` 中设置的位相对应的状态组件，并且它可以使用修改后的优化。
/// 根据 `save_mask` 和 `XCR0` 中的 `[62:0]` 位保存状态。
/// `mem_addr` 必须在 64 字节边界上对齐。
///
/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_xsaves64)
///
///
#[inline]
#[target_feature(enable = "xsave,xsaves")]
#[cfg_attr(test, assert_instr(xsaves64))]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _xsaves64(mem_addr: *mut u8, save_mask: u64) {
    xsaves64(mem_addr, (save_mask >> 32) as u32, save_mask as u32);
}

/// 使用 `mem_addr` 内存中存储的状态信息执行已启用处理器状态的全部或部分还原。
///
/// `xrstors` 与 `xrstor` 的不同之处在于它可以恢复与 `IA32_XSS` `MSR` 中设置的位相对应的状态组件； `xrstors` 无法从扩展区域为标准格式的 `xsave` 区域中恢复。
///
/// 根据 `rs_mask`，`XCR0` 和 `mem_addr.HEADER.XSTATE_BV` 中的 `[62:0]` 位恢复状态。`mem_addr` 必须在 64 字节边界上对齐。
///
/// [Intel's documentation](https://www.intel.com/content/www/us/en/docs/intrinsics-guide/index.html#text=_xrstors64)
///
///
///
///
#[inline]
#[target_feature(enable = "xsave,xsaves")]
#[cfg_attr(test, assert_instr(xrstors64))]
#[stable(feature = "simd_x86", since = "1.27.0")]
pub unsafe fn _xrstors64(mem_addr: *const u8, rs_mask: u64) {
    xrstors64(mem_addr, (rs_mask >> 32) as u32, rs_mask as u32);
}

// FIXME: https://github.com/rust-lang/stdarch/issues/209
// 所有这些测试均因 Intel SDE 而失败。
/*
#[cfg(test)]
mod tests {
    use crate::core_arch::x86::x86_64::xsave;
    use stdarch_test::simd_test;
    use std::fmt;

    // FIXME: https://github.com/rust-lang/stdarch/issues/209
    #[repr(align(64))]
    struct XsaveArea {
        // 256 位寄存器的最大大小为 800 字节：
        // see https://software.intel.com/en-us/node/682996
        // 512 位寄存器的最大大小为 2560 字节：
        // FIXME: 添加源
        data: [u8; 2560],
    }

    impl XsaveArea {
        fn new() -> XsaveArea {
            XsaveArea { data: [0; 2560] }
        }
        fn ptr(&mut self) -> *mut u8 {
            &mut self.data[0] as *mut _ as *mut u8
        }
    }

    impl PartialEq<XsaveArea> for XsaveArea {
        fn eq(&self, other: &XsaveArea) -> bool {
            for i in 0..self.data.len() {
                if self.data[i] != other.data[i] {
                    return false;
                }
            }
            true
        }
    }

    impl fmt::Debug for XsaveArea {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            write!(f, "[")?;
            for i in 0..self.data.len() {
                write!(f, "{}", self.data[i])?;
                if i != self.data.len() - 1 {
                    write!(f, ", ")?;
                }
            }
            write!(f, "]")
        }
    }

    #[simd_test(enable = "xsave")]
    unsafe fn xsave64() {
        let m = 0xFFFFFFFFFFFFFFFF_u64; // < 所有寄存器
        let mut a = XsaveArea::new();
        let mut b = XsaveArea::new();

        xsave::_xsave64(a.ptr(), m);
        xsave::_xrstor64(a.ptr(), m);
        xsave::_xsave64(b.ptr(), m);
        assert_eq!(a, b);
    }

    #[simd_test(enable = "xsave,xsaveopt")]
    unsafe fn xsaveopt64() {
        let m = 0xFFFFFFFFFFFFFFFF_u64; // < 所有寄存器
        let mut a = XsaveArea::new();
        let mut b = XsaveArea::new();

        xsave::_xsaveopt64(a.ptr(), m);
        xsave::_xrstor64(a.ptr(), m);
        xsave::_xsaveopt64(b.ptr(), m);
        assert_eq!(a, b);
    }

    #[simd_test(enable = "xsave,xsavec")]
    unsafe fn xsavec64() {
        let m = 0xFFFFFFFFFFFFFFFF_u64; // < 所有寄存器
        let mut a = XsaveArea::new();
        let mut b = XsaveArea::new();

        xsave::_xsavec64(a.ptr(), m);
        xsave::_xrstor64(a.ptr(), m);
        xsave::_xsavec64(b.ptr(), m);
        assert_eq!(a, b);
    }

    #[simd_test(enable = "xsave,xsaves")]
    unsafe fn xsaves64() {
        let m = 0xFFFFFFFFFFFFFFFF_u64; // < 所有寄存器
        let mut a = XsaveArea::new();
        let mut b = XsaveArea::new();

        xsave::_xsaves64(a.ptr(), m);
        xsave::_xrstors64(a.ptr(), m);
        xsave::_xsaves64(b.ptr(), m);
        assert_eq!(a, b);
    }
}
*/