Move the wasmtime crate directories form lib/* to wasmtime-*.

This follows a similar change to Cranelift made here:

https://github.com/CraneStation/cranelift/pull/660

wasmtime-runtime/src/traphandlers.rs

@@ -0,0 +1,137 @@
+//! WebAssembly trap handling, which is built on top of the lower-level
+//! signalhandling mechanisms.
+
+use crate::signalhandlers::jmp_buf;
+use crate::vmcontext::{VMContext, VMFunctionBody};
+use core::cell::{Cell, RefCell};
+use core::mem;
+use core::ptr;
+use libc::c_int;
+use std::string::String;
+use std::vec::Vec;
+
+// Currently we uset setjmp/longjmp to unwind out of a signal handler
+// and back to the point where WebAssembly was called (via `call_wasm`).
+// This works because WebAssembly code currently does not use any EH
+// or require any cleanups, and we never unwind through non-wasm frames.
+// In the future, we'll likely replace this with fancier stack unwinding.
+extern "C" {
+    fn setjmp(env: *mut jmp_buf) -> c_int;
+    fn longjmp(env: *const jmp_buf, val: c_int) -> !;
+}
+
+thread_local! {
+    static TRAP_PC: Cell<*const u8> = Cell::new(ptr::null());
+    static JMP_BUFS: RefCell<Vec<jmp_buf>> = RefCell::new(Vec::new());
+}
+
+/// Record the Trap code and wasm bytecode offset in TLS somewhere
+#[doc(hidden)]
+#[allow(non_snake_case)]
+#[no_mangle]
+pub extern "C" fn RecordTrap(pc: *const u8) {
+    // TODO: Look up the wasm bytecode offset and trap code and record them instead.
+    TRAP_PC.with(|data| data.set(pc));
+}
+
+/// Initiate an unwind.
+#[doc(hidden)]
+#[allow(non_snake_case)]
+#[no_mangle]
+pub extern "C" fn Unwind() {
+    JMP_BUFS.with(|bufs| {
+        let buf = bufs.borrow_mut().pop().unwrap();
+        unsafe { longjmp(&buf, 1) };
+    })
+}
+
+/// A simple guard to ensure that `JMP_BUFS` is reset when we're done.
+struct ScopeGuard {
+    orig_num_bufs: usize,
+}
+
+impl ScopeGuard {
+    fn new() -> Self {
+        assert_eq!(
+            TRAP_PC.with(Cell::get),
+            ptr::null(),
+            "unfinished trap detected"
+        );
+        Self {
+            orig_num_bufs: JMP_BUFS.with(|bufs| bufs.borrow().len()),
+        }
+    }
+}
+
+impl Drop for ScopeGuard {
+    fn drop(&mut self) {
+        let orig_num_bufs = self.orig_num_bufs;
+        JMP_BUFS.with(|bufs| {
+            bufs.borrow_mut()
+                .resize(orig_num_bufs, unsafe { mem::zeroed() })
+        });
+    }
+}
+
+fn trap_message(_vmctx: *mut VMContext) -> String {
+    let pc = TRAP_PC.with(|data| data.replace(ptr::null()));
+
+    // TODO: Record trap metadata in the VMContext, and look up the
+    // pc to obtain the TrapCode and SourceLoc.
+
+    format!("wasm trap at {:?}", pc)
+}
+
+fn push_jmp_buf(buf: jmp_buf) {
+    JMP_BUFS.with(|bufs| bufs.borrow_mut().push(buf));
+}
+
+/// Call the wasm function pointed to by `callee`. `values_vec` points to
+/// a buffer which holds the incoming arguments, and to which the outgoing
+/// return values will be written.
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_call_trampoline(
+    vmctx: *mut VMContext,
+    callee: *const VMFunctionBody,
+    values_vec: *mut u8,
+) -> Result<(), String> {
+    // Reset JMP_BUFS if the stack is unwound through this point.
+    let _guard = ScopeGuard::new();
+
+    // Set a setjmp catch point.
+    let mut buf = mem::uninitialized();
+    if setjmp(&mut buf) != 0 {
+        return Err(trap_message(vmctx));
+    }
+    push_jmp_buf(buf);
+
+    // Call the function!
+    let func: fn(*mut VMContext, *mut u8) = mem::transmute(callee);
+    func(vmctx, values_vec);
+
+    Ok(())
+}
+
+/// Call the wasm function pointed to by `callee`, which has no arguments or
+/// return values.
+#[no_mangle]
+pub unsafe extern "C" fn wasmtime_call(
+    vmctx: *mut VMContext,
+    callee: *const VMFunctionBody,
+) -> Result<(), String> {
+    // Reset JMP_BUFS if the stack is unwound through this point.
+    let _guard = ScopeGuard::new();
+
+    // Set a setjmp catch point.
+    let mut buf = mem::uninitialized();
+    if setjmp(&mut buf) != 0 {
+        return Err(trap_message(vmctx));
+    }
+    push_jmp_buf(buf);
+
+    // Call the function!
+    let func: fn(*mut VMContext) = mem::transmute(callee);
+    func(vmctx);
+
+    Ok(())
+}