Move x86_64-specific code to arch/x86_64

src/arch/mod.rs

@@ -0,0 +1 @@
+pub mod x86_64;

src/arch/x86_64/macros.rs

@@ -0,0 +1,181 @@
+/// Create an interrupt function that can safely run rust code
+#[macro_export]
+macro_rules! interrupt {
+    ($name:ident, $func:block) => {
+        #[naked]
+        pub unsafe extern fn $name () {
+            #[inline(never)]
+            unsafe fn inner() {
+                $func
+            }
+
+            // Push scratch registers
+            asm!("push rax
+                push rcx
+                push rdx
+                push rdi
+                push rsi
+                push r8
+                push r9
+                push r10
+                push r11
+                push fs
+                mov rax, 0x18
+                mov fs, ax"
+                : : : : "intel", "volatile");
+
+            // Call inner rust function
+            inner();
+
+            // Pop scratch registers and return
+            asm!("pop fs
+                pop r11
+                pop r10
+                pop r9
+                pop r8
+                pop rsi
+                pop rdi
+                pop rdx
+                pop rcx
+                pop rax
+                iretq"
+                : : : : "intel", "volatile");
+        }
+    };
+}
+
+#[allow(dead_code)]
+#[repr(packed)]
+pub struct InterruptStack {
+    pub fs: usize,
+    pub r11: usize,
+    pub r10: usize,
+    pub r9: usize,
+    pub r8: usize,
+    pub rsi: usize,
+    pub rdi: usize,
+    pub rdx: usize,
+    pub rcx: usize,
+    pub rax: usize,
+    pub rip: usize,
+    pub cs: usize,
+    pub rflags: usize,
+}
+
+#[macro_export]
+macro_rules! interrupt_stack {
+    ($name:ident, $stack: ident, $func:block) => {
+        #[naked]
+        pub unsafe extern fn $name () {
+            #[inline(never)]
+            unsafe fn inner($stack: &mut $crate::arch::x86_64::macros::InterruptStack) {
+                $func
+            }
+
+            // Push scratch registers
+            asm!("push rax
+                push rcx
+                push rdx
+                push rdi
+                push rsi
+                push r8
+                push r9
+                push r10
+                push r11
+                push fs
+                mov rax, 0x18
+                mov fs, ax"
+                : : : : "intel", "volatile");
+
+            // Get reference to stack variables
+            let rsp: usize;
+            asm!("" : "={rsp}"(rsp) : : : "intel", "volatile");
+
+            // Call inner rust function
+            inner(&mut *(rsp as *mut $crate::arch::x86_64::macros::InterruptStack));
+
+            // Pop scratch registers and return
+            asm!("pop fs
+                pop r11
+                pop r10
+                pop r9
+                pop r8
+                pop rsi
+                pop rdi
+                pop rdx
+                pop rcx
+                pop rax
+                iretq"
+                : : : : "intel", "volatile");
+        }
+    };
+}
+
+#[allow(dead_code)]
+#[repr(packed)]
+pub struct InterruptErrorStack {
+    pub fs: usize,
+    pub r11: usize,
+    pub r10: usize,
+    pub r9: usize,
+    pub r8: usize,
+    pub rsi: usize,
+    pub rdi: usize,
+    pub rdx: usize,
+    pub rcx: usize,
+    pub rax: usize,
+    pub code: usize,
+    pub rip: usize,
+    pub cs: usize,
+    pub rflags: usize,
+}
+
+#[macro_export]
+macro_rules! interrupt_error {
+    ($name:ident, $stack:ident, $func:block) => {
+        #[naked]
+        pub unsafe extern fn $name () {
+            #[inline(never)]
+            unsafe fn inner($stack: &$crate::arch::x86_64::macros::InterruptErrorStack) {
+                $func
+            }
+
+            // Push scratch registers
+            asm!("push rax
+                push rcx
+                push rdx
+                push rdi
+                push rsi
+                push r8
+                push r9
+                push r10
+                push r11
+                push fs
+                mov rax, 0x18
+                mov fs, ax"
+                : : : : "intel", "volatile");
+
+            // Get reference to stack variables
+            let rsp: usize;
+            asm!("" : "={rsp}"(rsp) : : : "intel", "volatile");
+
+            // Call inner rust function
+            inner(&*(rsp as *const $crate::arch::x86_64::macros::InterruptErrorStack));
+
+            // Pop scratch registers, error code, and return
+            asm!("pop fs
+                pop r11
+                pop r10
+                pop r9
+                pop r8
+                pop rsi
+                pop rdi
+                pop rdx
+                pop rcx
+                pop rax
+                add rsp, 8
+                iretq"
+                : : : : "intel", "volatile");
+        }
+    };
+}

src/arch/x86_64/mod.rs

@@ -0,0 +1,23 @@
+#[macro_use]
+pub mod macros;
+
+/// Devices
+pub mod device;
+
+/// Global descriptor table
+pub mod gdt;
+
+/// Interrupt descriptor table
+pub mod idt;
+
+/// Interrupt instructions
+pub mod interrupt;
+
+/// Paging
+pub mod paging;
+
+/// Initialization and start function
+pub mod start;
+
+/// Stop function
+pub mod stop;

src/lib.rs

@@ -52,45 +52,29 @@ pub mod consts;
 /// ACPI table parsing
 mod acpi;
 
+/// Architecture-dependent stuff
+mod arch;
+#[cfg(target_arch = "x86_64")]
+pub use arch::x86_64::*;
+
 /// Context management
 pub mod context;
 
-/// Devices
-pub mod device;
-
 /// ELF file parsing
 pub mod elf;
 
 /// External functions
 pub mod externs;
 
-/// Global descriptor table
-pub mod gdt;
-
-/// Interrupt descriptor table
-mod idt;
-
-/// Interrupt instructions
-pub mod interrupt;
-
 /// Memory management
 pub mod memory;
 
-/// Paging
-pub mod paging;
-
 /// Panic
 pub mod panic;
 
 /// Schemes, filesystem handlers
 pub mod scheme;
 
-/// Initialization and start function
-pub mod start;
-
-/// Shutdown function
-pub mod stop;
-
 /// Synchronization primitives
 pub mod sync;
 

src/macros.rs

@@ -14,185 +14,3 @@ macro_rules! println {
     ($fmt:expr) => (print!(concat!($fmt, "\n")));
     ($fmt:expr, $($arg:tt)*) => (print!(concat!($fmt, "\n"), $($arg)*));
 }
-
-/// Create an interrupt function that can safely run rust code
-#[macro_export]
-macro_rules! interrupt {
-    ($name:ident, $func:block) => {
-        #[naked]
-        pub unsafe extern fn $name () {
-            #[inline(never)]
-            unsafe fn inner() {
-                $func
-            }
-
-            // Push scratch registers
-            asm!("push rax
-                push rcx
-                push rdx
-                push rdi
-                push rsi
-                push r8
-                push r9
-                push r10
-                push r11
-                push fs
-                mov rax, 0x18
-                mov fs, ax"
-                : : : : "intel", "volatile");
-
-            // Call inner rust function
-            inner();
-
-            // Pop scratch registers and return
-            asm!("pop fs
-                pop r11
-                pop r10
-                pop r9
-                pop r8
-                pop rsi
-                pop rdi
-                pop rdx
-                pop rcx
-                pop rax
-                iretq"
-                : : : : "intel", "volatile");
-        }
-    };
-}
-
-#[allow(dead_code)]
-#[repr(packed)]
-pub struct InterruptStack {
-    pub fs: usize,
-    pub r11: usize,
-    pub r10: usize,
-    pub r9: usize,
-    pub r8: usize,
-    pub rsi: usize,
-    pub rdi: usize,
-    pub rdx: usize,
-    pub rcx: usize,
-    pub rax: usize,
-    pub rip: usize,
-    pub cs: usize,
-    pub rflags: usize,
-}
-
-#[macro_export]
-macro_rules! interrupt_stack {
-    ($name:ident, $stack: ident, $func:block) => {
-        #[naked]
-        pub unsafe extern fn $name () {
-            #[inline(never)]
-            unsafe fn inner($stack: &mut $crate::macros::InterruptStack) {
-                $func
-            }
-
-            // Push scratch registers
-            asm!("push rax
-                push rcx
-                push rdx
-                push rdi
-                push rsi
-                push r8
-                push r9
-                push r10
-                push r11
-                push fs
-                mov rax, 0x18
-                mov fs, ax"
-                : : : : "intel", "volatile");
-
-            // Get reference to stack variables
-            let rsp: usize;
-            asm!("" : "={rsp}"(rsp) : : : "intel", "volatile");
-
-            // Call inner rust function
-            inner(&mut *(rsp as *mut $crate::macros::InterruptStack));
-
-            // Pop scratch registers and return
-            asm!("pop fs
-                pop r11
-                pop r10
-                pop r9
-                pop r8
-                pop rsi
-                pop rdi
-                pop rdx
-                pop rcx
-                pop rax
-                iretq"
-                : : : : "intel", "volatile");
-        }
-    };
-}
-
-#[allow(dead_code)]
-#[repr(packed)]
-pub struct InterruptErrorStack {
-    pub fs: usize,
-    pub r11: usize,
-    pub r10: usize,
-    pub r9: usize,
-    pub r8: usize,
-    pub rsi: usize,
-    pub rdi: usize,
-    pub rdx: usize,
-    pub rcx: usize,
-    pub rax: usize,
-    pub code: usize,
-    pub rip: usize,
-    pub cs: usize,
-    pub rflags: usize,
-}
-
-#[macro_export]
-macro_rules! interrupt_error {
-    ($name:ident, $stack:ident, $func:block) => {
-        #[naked]
-        pub unsafe extern fn $name () {
-            #[inline(never)]
-            unsafe fn inner($stack: &$crate::macros::InterruptErrorStack) {
-                $func
-            }
-
-            // Push scratch registers
-            asm!("push rax
-                push rcx
-                push rdx
-                push rdi
-                push rsi
-                push r8
-                push r9
-                push r10
-                push r11
-                push fs
-                mov rax, 0x18
-                mov fs, ax"
-                : : : : "intel", "volatile");
-
-            // Get reference to stack variables
-            let rsp: usize;
-            asm!("" : "={rsp}"(rsp) : : : "intel", "volatile");
-
-            // Call inner rust function
-            inner(&*(rsp as *const $crate::macros::InterruptErrorStack));
-
-            // Pop scratch registers, error code, and return
-            asm!("pop fs
-                pop r11
-                pop r10
-                pop r9
-                pop r8
-                pop rsi
-                pop rdi
-                pop rdx
-                pop rcx
-                pop rax
-                add rsp, 8
-                iretq"
-                : : : : "intel", "volatile");
-        }
-    };
-}