Fix panic_handler (#2)

- Last implementation caused undefined behavior by executing a nonexistent exception handler.

Author: parasyte

src/lib.rs

@@ -1,6 +1,7 @@
 #![feature(core_intrinsics)]
 #![feature(global_asm)]
 #![feature(lang_items)]
+#![feature(llvm_asm)]
 #![warn(rust_2018_idioms)]
 #![allow(unused_attributes)]
 #![no_std]
@@ -14,32 +15,32 @@ use core::panic::PanicInfo;
 /// This is the executable start function, which directly follows the entry point.
 #[cfg_attr(not(test), lang = "start")]
 #[cfg(not(test))]
-extern "C" fn start<T>(user_main: *const (), _argc: isize, _argv: *const *const u8) -> isize
+extern "C" fn start<T>(user_main: *const (), _argc: isize, _argv: *const *const u8) -> !
 where
     T: Termination,
 {
     let user_main: fn() -> T = unsafe { core::mem::transmute(user_main) };
-    user_main().report() as isize
+    user_main();
+
+    panic!("main() cannot return");
 }
 
 /// Termination trait required for the start function.
 #[cfg_attr(not(test), lang = "termination")]
-trait Termination {
-    fn report(self) -> i32;
-}
+trait Termination {}
 
 /// This implementation does the bare minimum to satisfy the executable start function.
-impl Termination for () {
-    fn report(self) -> i32 {
-        0
-    }
-}
+impl Termination for () {}
 
 /// This function is called on panic.
 #[cfg_attr(not(test), panic_handler)]
 #[no_mangle]
 fn panic(_info: &PanicInfo<'_>) -> ! {
-    core::intrinsics::abort();
+    loop {
+        // A loop without side effects may be optimized away by LLVM. This issue can be avoided with
+        // a volatile no-op. See: https://github.com/rust-lang/rust/issues/28728
+        unsafe { llvm_asm!("" :::: "volatile") };
+    }
 }
 
 /// Error handler personality language item (current no-op, to satisfy clippy).

src/platforms/n64/entrypoint.s

@@ -50,17 +50,6 @@ _start:
     li $t1, FS_START
     sw $t0, 0($t1)
 
-    // So if we want to get fancy, we can load a second stage here.
-    // The second stage should contain an ELF parser and TLB Initialization.
-    // The ELF (kernel image) should be loaded into virtual memory by the second
-    // stage, and its entry point executed.
-
     // Jump to Rust
     jal main
     nop
-
-    // Panic!
-    // We can't do much here aside from looping
-1:
-    j 1b
-    nop