Initial stab at a context switching tools library

Author: npmccallum

.github/workflows/lint.yml

@@ -0,0 +1,36 @@
+on: [push, pull_request]
+
+name: lint
+
+jobs:
+  fmt:
+    name: cargo fmt
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          components: rustfmt
+          toolchain: nightly
+          profile: minimal
+          override: true
+      - uses: actions-rs/cargo@v1
+        with:
+          command: fmt
+          args: --all -- --check
+
+  clippy:
+    name: cargo clippy
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          components: clippy
+          toolchain: nightly
+          profile: minimal
+          override: true
+      - uses: actions-rs/cargo@v1
+        with:
+          command: clippy
+          args: -- -D warnings

.github/workflows/test.yml

@@ -0,0 +1,47 @@
+
+on: [push, pull_request]
+name: test
+jobs:
+  test:
+    name: ${{ matrix.config.target }}
+    runs-on: ${{ matrix.config.os }}-latest
+    steps:
+      - run: ${{ matrix.config.prep }}
+      - uses: actions/checkout@v2
+      - uses: actions-rs/toolchain@v1
+        with:
+          target: ${{ matrix.config.target }}
+          toolchain: nightly
+          override: true
+      - uses: actions-rs/cargo@v1
+        with:
+          command: test
+          args: --release --target=${{ matrix.config.target }}
+    strategy:
+      fail-fast: false
+      matrix:
+        config:
+          - target: i586-pc-windows-msvc
+            os: windows
+          - target: i586-unknown-linux-gnu
+            prep: sudo apt install -y gcc-multilib
+            os: ubuntu
+          - target: i586-unknown-linux-musl
+            os: ubuntu
+          - target: i686-pc-windows-msvc
+            os: windows
+          - target: i686-unknown-linux-gnu
+            prep: sudo apt install -y gcc-multilib
+            os: ubuntu
+          - target: i686-unknown-linux-musl
+            os: ubuntu
+          - target: x86_64-apple-darwin
+            os: macos
+          - target: x86_64-pc-windows-gnu
+            os: windows
+          - target: x86_64-pc-windows-msvc
+            os: windows
+          - target: x86_64-unknown-linux-gnu
+            os: ubuntu
+          - target: x86_64-unknown-linux-musl
+            os: ubuntu

.gitignore

@@ -0,0 +1,2 @@
+/target
+Cargo.lock

Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "frenetic"
+version = "0.1.0"
+authors = ["Nathaniel McCallum <[email protected]>"]
+edition = "2018"
+license = "Apache-2.0"
+
+categories = ["no-std"]
+keywords = ["no_std"]

src/arch/mod.rs

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+mod x86;
+
+#[cfg(target_arch = "x86_64")]
+mod x86_64;
+
+#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+pub use x86::Extended;
+
+#[cfg(target_arch = "x86")]
+pub use x86::Basic;
+
+#[cfg(target_arch = "x86_64")]
+pub use x86_64::Basic;

src/arch/x86/mod.rs

@@ -0,0 +1,188 @@
+// SPDX-License-Identifier: Apache-2.0
+
+use core::mem::size_of;
+
+#[derive(Default)]
+#[repr(C, align(16))]
+#[cfg(target_arch = "x86")]
+pub struct Basic([usize; 6]);
+
+#[cfg(target_arch = "x86")]
+impl Basic {
+    #[inline(never)]
+    pub extern "C" fn wipe() {
+        unsafe {
+            asm!(
+                "xor     eax, eax",
+                "xor     ecx, ecx",
+                "xor     edx, edx",
+                "add     eax, eax",
+                "cld",
+                out("eax") _,
+                out("ecx") _,
+                out("edx") _,
+            )
+        }
+    }
+
+    #[naked]
+    #[must_use]
+    #[inline(never)]
+    pub extern "fastcall" fn save(&mut self) -> bool {
+        unsafe {
+            asm!(
+                "pop    edx",
+                "mov    [ecx + 0x00], edi",
+                "mov    [ecx + 0x04], esi",
+                "mov    [ecx + 0x08], ebx",
+                "mov    [ecx + 0x0a], ebp",
+                "mov    [ecx + 0x10], esp",
+                "mov    [ecx + 0x14], edx",
+                "mov    eax, 1",
+                "jmp    edx",
+                options(noreturn)
+            )
+        }
+    }
+
+    #[naked]
+    #[inline(never)]
+    pub unsafe extern "fastcall" fn load(&self) -> ! {
+        asm!(
+            "mov     eax, 0",
+            "mov     edi, [ecx + 0x00]",
+            "mov     esi, [ecx + 0x04]",
+            "mov     ebx, [ecx + 0x08]",
+            "mov     ebp, [ecx + 0x0a]",
+            "mov     esp, [ecx + 0x10]",
+            "jmp          [ecx + 0x14]",
+            options(noreturn)
+        )
+    }
+}
+
+#[derive(Copy, Clone)]
+#[repr(C, align(16))]
+struct Mm([u8; 10], [u8; 6]);
+
+#[derive(Copy, Clone)]
+#[repr(C, align(16))]
+struct Xmm([u8; 16]);
+
+#[derive(Copy, Clone)]
+#[repr(C, align(64))]
+struct Legacy {
+    fcw: u16,
+    fsw: u16,
+    ftw: u8,
+    reserved: u8,
+    fop: u16,
+    fip: u64,
+    fdp: u64,
+    mxcsr: u32,
+    mxcsr_mask: u32,
+    mm: [Mm; 8],
+    xmm: [Xmm; 16],
+    unused: [u64; 12],
+}
+
+#[derive(Copy, Clone)]
+#[repr(C, align(64))]
+struct Header {
+    xstate_bv: u64,
+    xcomp_bv: u64,
+    reserved: [u64; 6],
+}
+
+#[derive(Copy, Clone)]
+#[repr(C, align(4096))]
+pub struct XSave {
+    legacy: Legacy,
+    header: Header,
+    extend: [u8; XSave::fill()],
+}
+
+impl XSave {
+    const DEFAULT: XSave = XSave {
+        legacy: Legacy {
+            fcw: 0x037F,
+            fsw: 0,
+            ftw: 0,
+            reserved: 0,
+            fop: 0,
+            fip: 0,
+            fdp: 0,
+            mxcsr: 0x1F80,
+            mxcsr_mask: 0xFFFF,
+            mm: [Mm([0; 10], [0; 6]); 8],
+            xmm: [Xmm([0; 16]); 16],
+            unused: [0; 12],
+        },
+
+        header: Header {
+            xstate_bv: 0,
+            xcomp_bv: 0,
+            reserved: [0; 6],
+        },
+
+        extend: [0; XSave::fill()],
+    };
+
+    const fn fill() -> usize {
+        4096 - size_of::<Legacy>() - size_of::<Header>()
+    }
+}
+
+#[repr(transparent)]
+pub struct Extended(XSave);
+
+impl Default for Extended {
+    fn default() -> Self {
+        Self(XSave::DEFAULT)
+    }
+}
+
+impl Extended {
+    #[inline(always)]
+    pub fn wipe() {
+        Self(XSave::DEFAULT).load()
+    }
+
+    #[inline(never)]
+    pub extern "C" fn save(&mut self) {
+        unsafe {
+            asm!(
+                "mov     eax, ~0",
+                "mov     edx, ~0",
+                "xsave   [{}]",
+
+                in(reg) &mut self.0,
+                out("eax") _,
+                out("edx") _,
+            )
+        }
+    }
+
+    #[inline(never)]
+    pub extern "C" fn load(&self) {
+        unsafe {
+            asm!(
+                "mov     eax, ~0",
+                "mov     edx, ~0",
+                "xrstor  [{}]",
+
+                in(reg) &self.0,
+                out("eax") _,
+                out("edx") _,
+            )
+        }
+    }
+}
+
+#[cfg(test)]
+#[test]
+fn size() {
+    assert_eq!(size_of::<Header>(), 64);
+    assert_eq!(size_of::<Legacy>(), 512);
+    assert_eq!(size_of::<XSave>(), 4096);
+}

src/arch/x86_64/mod.rs

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#[cfg(not(target_os = "windows"))]
+mod sysv;
+
+#[cfg(not(target_os = "windows"))]
+pub use sysv::Basic;
+
+#[cfg(target_os = "windows")]
+mod win;
+
+#[cfg(target_os = "windows")]
+pub use win::Basic;

src/arch/x86_64/sysv.rs

@@ -0,0 +1,70 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#[derive(Default)]
+#[repr(C, align(16))]
+pub struct Basic([usize; 8]);
+
+impl Basic {
+    #[naked]
+    #[inline(never)]
+    pub extern "C" fn wipe() {
+        unsafe {
+            asm!(
+                "xor     rax, rax",
+                "xor     rcx, rcx",
+                "xor     rdx, rdx",
+                "xor     rdi, rdi",
+                "xor     rsi, rsi",
+                "xor     r8,  r8",
+                "xor     r9,  r9",
+                "xor     r10, r10",
+                "xor     r11, r11",
+                "add     rax, rax",
+                "cld",
+                "ret",
+                options(noreturn)
+            )
+        }
+    }
+
+    #[naked]
+    #[must_use]
+    #[inline(never)]
+    pub extern "C" fn save(&mut self) -> bool {
+        unsafe {
+            asm!(
+                "pop    rsi",
+                "mov    [rdi + 0x00], r15",
+                "mov    [rdi + 0x08], r14",
+                "mov    [rdi + 0x10], r13",
+                "mov    [rdi + 0x18], r12",
+                "mov    [rdi + 0x20], rbx",
+                "mov    [rdi + 0x28], rbp",
+                "mov    [rdi + 0x30], rsp",
+                "mov    [rdi + 0x38], rsi",
+                "mov    rax, 1",
+                "jmp    rsi",
+                in("rdi") self,
+                options(noreturn)
+            )
+        }
+    }
+
+    #[naked]
+    #[inline(never)]
+    pub unsafe extern "C" fn load(&self) -> ! {
+        asm!(
+            "mov     rax, 0",
+            "mov     r15, qword ptr [rdi + 0x00]",
+            "mov     r14, qword ptr [rdi + 0x08]",
+            "mov     r13, qword ptr [rdi + 0x10]",
+            "mov     r12, qword ptr [rdi + 0x18]",
+            "mov     rbx, qword ptr [rdi + 0x20]",
+            "mov     rbp, qword ptr [rdi + 0x28]",
+            "mov     rsp, qword ptr [rdi + 0x30]",
+            "jmp          qword ptr [rdi + 0x38]",
+            in("rdi") self,
+            options(noreturn)
+        )
+    }
+}