Add test architecture

arch/test/Cargo.toml

@@ -0,0 +1,3 @@
+[package]
+name = "arch_test"
+version = "0.1.0"

arch/test/src/interrupt.rs

@@ -0,0 +1,24 @@
+//! Interrupt instructions
+
+static mut INTERRUPTS_ENABLED: bool = false;
+
+/// Clear interrupts
+#[inline(always)]
+pub unsafe fn clear_interrupts() {
+    println!("CLEAR INTERRUPTS");
+    INTERRUPTS_ENABLED = false;
+}
+
+/// Set interrupts
+#[inline(always)]
+pub unsafe fn set_interrupts() {
+    println!("SET INTERRUPTS");
+    INTERRUPTS_ENABLED = true;
+}
+
+/// Halt instruction
+#[inline(always)]
+pub unsafe fn halt() {
+    assert!(INTERRUPTS_ENABLED);
+    ::std::thread::yield_now();
+}

arch/test/src/lib.rs

@@ -0,0 +1,40 @@
+//! Architecture support for testing
+
+pub use std::io;
+
+/// Print to console
+#[macro_export]
+macro_rules! print {
+    ($($arg:tt)*) => ({
+        use $crate::io::Write;
+        let _ = write!($crate::io::stdout(), $($arg)*);
+    });
+}
+
+/// Print with new line to console
+#[macro_export]
+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) => {
+        pub unsafe extern fn $name () {
+            unsafe fn inner() {
+                $func
+            }
+
+            // Call inner rust function
+            inner();
+        }
+    };
+}
+
+/// Interrupt instructions
+pub mod interrupt;
+
+/// Initialization and main function
+pub mod main;

arch/test/src/main.rs

@@ -0,0 +1,11 @@
+/// This function is where the kernel sets up IRQ handlers
+/// It is increcibly unsafe, and should be minimal in nature
+
+extern {
+    fn kmain() -> !;
+}
+
+#[no_mangle]
+pub unsafe extern fn kstart() -> ! {
+    kmain();
+}

arch/x86_64/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "arch"
+name = "arch_x86_64"
 version = "0.1.0"
 
 [dependencies]