6def6de5e0
* Remove cmake/bindgen/llvm from wasmtime-runtime This commit removes the cmake/bindgen dependency (which removes the need for `llvm-config`) from the `wasmtime-runtime` crate. The C++ code is instead compiled with the `cc` crate (it's just one file anyway) and the interface is handwritten since it's quite small anyway. Some other changes are: * The `TrapContext` type in C++ was removed since it was unused, and it was moved to Rust with a `Cell` on each field. * Functions between Rust/C++ now return `int` instead of `bool` to make them a bit more FFI compatible portably. * The `jmp_buf` type has a workaround that will be fixed in the next commit. * Move setjmp/longjmp to C++ This commit moves the definition of setjmp and longjmp into C++. This is primarily done because it's [debatable whether it's possible to call `setjmp` from Rust][rfc]. The semantics of `setjmp` are that it returns twice but LLVM doesn't actually know about this because rustc isn't telling LLVM this information, so it's unclear whether it can ever be safe. Additionally this removes the need for Rust code to know the definition of `jmp_buf` which is a pretty hairy type to define in Rust across platforms. The solution in this commit is to move all setjmp/longjmp code to C++, and that way we should be able to guarantee that jumps over wasm JIT code should always go from C++ to C++, removing Rust from the equation for now from needing to get any fiddly bits working across platforms. This should overall help it be a bit more portable and also means Rust doesn't have to know about `jmp_buf` as a type. The previous `Vec` of `jmp_buf` is now replaced with one thread-local pointer where previous values are stored on the stack and restored when the function returns. This is intended to be functionally the same as the previous implementation. [rfc]: https://github.com/rust-lang/rfcs/issues/2625 * rustfmt * Use volatile loads/stores * Remove mention of cmake from README
45 lines
1.3 KiB
C++
45 lines
1.3 KiB
C++
#ifndef signal_handlers_h
|
|
#define signal_handlers_h
|
|
|
|
#include <stdint.h>
|
|
#include <setjmp.h>
|
|
#ifndef __cplusplus
|
|
#include <stdbool.h>
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
// Record the Trap code and wasm bytecode offset in TLS somewhere
|
|
void RecordTrap(const uint8_t* pc);
|
|
|
|
void* EnterScope(void*);
|
|
void LeaveScope(void*);
|
|
void* GetScope(void);
|
|
void Unwind(void);
|
|
|
|
// This function performs the low-overhead signal handler initialization that we
|
|
// want to do eagerly to ensure a more-deterministic global process state. This
|
|
// is especially relevant for signal handlers since handler ordering depends on
|
|
// installation order: the wasm signal handler must run *before* the other crash
|
|
// handlers and since POSIX signal handlers work LIFO, this function needs to be
|
|
// called at the end of the startup process, after other handlers have been
|
|
// installed. This function can thus be called multiple times, having no effect
|
|
// after the first call.
|
|
int
|
|
EnsureEagerSignalHandlers(void);
|
|
|
|
// Assuming EnsureEagerProcessSignalHandlers() has already been called,
|
|
// this function performs the full installation of signal handlers which must
|
|
// be performed per-thread. This operation may incur some overhead and
|
|
// so should be done only when needed to use wasm.
|
|
int
|
|
EnsureDarwinMachPorts(void);
|
|
|
|
#ifdef __cplusplus
|
|
} // extern "C"
|
|
#endif
|
|
|
|
#endif // signal_handlers_h
|