Changes in stack_overflow.rs

2283e84f - Fix a panic with a massive `max_wasm_stack` configured (#12869)

Mon, 30 Mar 2026 18:32:56 +0000

Fix a panic with a massive `max_wasm_stack` configured (#12869)* Fix a panic with a massive `max_wasm_stack` configuredThis commit fixes a panic through a `checked_add(...).unwrap()` whichcan happen when `Config::max_wasm_stack` is configured to be a verylarge value. This is a mostly benign panic as it's unlikely this isconfigured much in the wild, but nevertheless seems like a good issuesto fix regardless.* Fix an overflow/OOM panic in pulleyprtest:full* Fix CI* Another CI fix* Fix test on 32-bit* Fix miri test List of files: /wasmtime-44.0.1/tests/all/stack_overflow.rs

45f8b2a7 - Re-enable single-pass regalloc in fuzzing (#11721)

Fri, 19 Sep 2025 18:03:32 +0000

Re-enable single-pass regalloc in fuzzing (#11721)Follow-up to #11712 List of files: /wasmtime-44.0.1/tests/all/stack_overflow.rs

192f2fcd - Replace setjmp/longjmp usage in Wasmtime (#11592)

Mon, 08 Sep 2025 14:33:31 +0000

Replace setjmp/longjmp usage in Wasmtime (#11592)Since Wasmtime's inception it's used the `setjmp` and `longjmp`functions in C to implement handling of traps. While this solution waseasy to implement, relatively portable, and performant enough, there area number of downsides that have evolved over time to make this anunattractive approach in the long run:* Using `setjmp` fundamentally requires using C because Rust does not understand a function that returns twice. It's fundamentally unsound to invoke `setjmp` in Rust meaning that Wasmtime has forever needed a C compiler configured and set up to build. This notably means that `cargo check` cannot check other targets easily.* Using `longjmp` means that Rust function frames are unwound on the stack without running destructors. This is a dangerous operation of which we get no protection from the compiler about. Both frames entering wasm and frames exiting wasm are all skipped. Absolutely minimizing this has been beneficial for portability to platforms such as Pulley.* Currently the no_std implementation of Wasmtime requires embedders to provide `wasmtime_{setjmp,longjmp}` which is a thorn in the side of what is otherwise a mostly entirely independent implementation of Wasmtime.* There is a performance floor to using `setjmp` and `longjmp`. Calling `setjmp` requires using C but Wasmtime is otherwise written in Rust meaning that there's a Rust->C->Rust->Wasm boundary which fundamentally can't be inlined without cross-language LTO which is difficult to configure.* With the implementation of the WebAssembly exceptions proposal Wasmtime now has two means of unwinding the stack. Ideally Wasmtime would only have one, and the more general one is the method of exceptions.* Jumping out of a signal handler on Unix is tricky business. While we've made it work it's generally most robust of the signal handler simply returns which it now does.With all of that in mind the purpose of this commit is to replace thesetjmp/longjmp mechanism of handling traps with the recently implementedsupport for exceptions in Cranelift. That is intended to resolve all ofthe above points in one swoop.One point in particular though that's nice about setjmp/longjmp is thatunwinding the stack on a trap is an O(1) operation. For situations suchas stack overflow that's a particularly nice property to have as we canguarantee embedders that traps are a constant time (albeit somewhatexpensive with signals) operation. Exceptions naively require unwindingthe entire stack, and although frame pointers mean we're just traversinga linked list I wanted to preserve the O(1) property here nonetheless.To achieve this a solution is implemented where the array-to-wasm(host-to-wasm) trampolines setup state in `VMStoreContext` so looking upthe current trap handler frame is an O(1) operation. Namely the sp/fp/pcvalues for a `Handler` are stored inline.Implementing this feature required supportingrelocations-to-offsets-in-functions which was not previously supportedby Wasmtime. This required Cranelift refactorings such as #11570, #11585,and #11576. This then additionally required some more refactoring inthis commit which was difficult to split out as it otherwise wouldn't betested.Apart from the relocation-related business much of this change is aboutupdating the platform signal handlers to use exceptions instead oflongjmp to return. For example on Unix this means updating the`ucontext_t` with register values that the handler specifies. Windowsinvolves updating similar contexts, and macOS mach ports ended up notneeding too many changes.In terms of overall performance the relevant benchmark from thisrepository, compared to before this commit, is: sync/no-hook/core - host-to-wasm - typed - nop time: [10.552 ns 10.561 ns 10.571 ns] change: [−7.5238% −7.4011% −7.2786%] (p = 0.00 < 0.05) Performance has improved.Closes #3927cc #10923prtest:full List of files: /wasmtime-44.0.1/tests/all/stack_overflow.rs

73de2ee9 - Pull in new regalloc2 with fastalloc fixes for exceptions, and re-enable and add to testing. (#11533)

Mon, 25 Aug 2025 19:22:21 +0000

Pull in new regalloc2 with fastalloc fixes for exceptions, and re-enable and add to testing. (#11533)* Revert "Cranelift/Wasmtime: disable fastalloc (single-pass) allocator for now. (#10554)"This reverts commit d52e23b09191185996792b8ef18e5fca2865ca43.* Upgrade to regalloc2 0.13.1.Pulls in bytecodealliance/regalloc2#233 to update fastalloc to supportthe looser constraints needed by exception-related changes.* cargo-vet update. List of files: /wasmtime-44.0.1/tests/all/stack_overflow.rs

47bc186d - Skip some tests with ASAN (#11399)

Thu, 07 Aug 2025 23:35:57 +0000

Skip some tests with ASAN (#11399)ASAN is the longest builder right now and many of the slow tests aren'treally buying much such as:* `disas` - no `unsafe` code* `wast` - no need to test all permutations of compilers/collectors and instead one should suffice* `all` - various tests taking 1m+ were flagged to ignore under ASAN as it's not necessarily important to run 100% of tests under ASAN. List of files: /wasmtime-44.0.1/tests/all/stack_overflow.rs

d52e23b0 - Cranelift/Wasmtime: disable fastalloc (single-pass) allocator for now. (#10554)

Wed, 09 Apr 2025 00:14:27 +0000

Cranelift/Wasmtime: disable fastalloc (single-pass) allocator for now. (#10554)Unfortunately, as discovered by a recent fuzzbug [1], the single-passregister allocator is not compatible with the approach to callsitedefs that exception-handling support has forced us to take. Inparticular, we needed to move all call return-value defs onto the callinstruction itself, so calls could be terminators; this unboundednumber of defs is made to be a solvable allocation problem by using`any` constraints, which allow allocation directly into spillslots;but fastalloc appears to error out if it runs out of registers,regardless of this constraint.Long-term, we should fix this, but unfortunately I don't have cyclesto dive into fastalloc's internals at the moment, and it's (I think) atier-3 feature. As such, this PR disables its use for now. I'vefiled a tracking issue in RA2 [2], and referenced this in theCranelift configuration option docs at least.To keep from shifting all fuzzbugs / fuzzing corpii by altering the`arbitrary` interpretation, I opted to keep the enum the same in thefuzzing crate, and remap `SinglePass` to `Backtracking` there. I'mhappy to take the other approach and remove the option (thusinvalidating all fuzzbugs) if we'd prefer that instead.[1]: https://oss-fuzz.com/testcase-detail/5433312476987392[2]: https://github.com/bytecodealliance/regalloc2/issues/217 List of files: /wasmtime-44.0.1/tests/all/stack_overflow.rs

e32292c9 - Speed up a "big stack" test, and test Winch (#9636)

Wed, 20 Nov 2024 19:25:55 +0000

Speed up a "big stack" test, and test Winch (#9636)* Speed up a "big stack" test, and test WinchThis test currently takes 50s locally in debug mode locally so optimizeit by disabling optimizations in Cranelift and additionally using thesingle-pass register allocator. This drops the test time to ~3s locally.* Fix test comments List of files: /wasmtime-44.0.1/tests/all/stack_overflow.rs

13342b24 - Enhance test around stack overflow (#8149)

Mon, 18 Mar 2024 19:07:01 +0000

Enhance test around stack overflow (#8149)* Enhance test around stack overflowThis commit enhances the `host_always_has_some_stack` a bit in light ofsome thinking around #8135. Notably this test ensures that the hostitself never segfaults even if the wasm exhausts all of its stack. Thereare a number of ways that we can exit out to the host, though, and onlyone was tested previously. This commit updates to ensure more cases arecovered.* Fix test to test correct thing* Update tests/all/stack_overflow.rsCo-authored-by: Nick Fitzgerald ---------Co-authored-by: Nick Fitzgerald List of files: /wasmtime-44.0.1/tests/all/stack_overflow.rs

9ce3ffe1 - Update some CI dependencies (#7983)

Thu, 22 Feb 2024 23:54:03 +0000

Update some CI dependencies (#7983)* Update some CI dependencies* Update to the latest nightly toolchain* Update mdbook* Update QEMU for cross-compiled testing* Update `cargo nextest` for usage with MIRIprtest:full* Remove lots of unnecessary imports* Downgrade qemu as 8.2.1 seems to segfault* Remove more imports* Remove unused winch trait method* Fix warnings about unused trait methods* More unused imports* More unused imports List of files: /wasmtime-44.0.1/tests/all/stack_overflow.rs

c0bb341d - Run some tests in MIRI on CI (#6332)

Wed, 03 May 2023 21:02:33 +0000

Run some tests in MIRI on CI (#6332)* Run some tests in MIRI on CIThis commit is an implementation of getting at least chunks of Wasmtimeto run in MIRI on CI. The full test suite is not possible to run in MIRIbecause MIRI cannot run Cranelift-produced code at runtime (aka itdoesn't support JITs). Running MIRI, however, is still quite valuable ifwe can manage it because it would have trivially detectedGHSA-ch89-5g45-qwc7, our most recent security advisory. The goal of thisPR is to select a subset of the test suite to execute in CI under MIRIand boost our confidence in the copious amount of `unsafe` code inWasmtime's runtime.Under MIRI's default settings, which is to use the [StackedBorrows][stacked] model, much of the code in `Instance` and `VMContext`is considered invalid. Under the optional [Tree Borrows][tree] model,however, this same code is accepted. After some [extremely helpfuldiscussion][discuss] on the Rust Zulip my current conclusion is thatwhat we're doing is not fundamentally un-sound but we need to model itin a different way. This PR, however, uses the Tree Borrows model forMIRI to get something onto CI sooner rather than later, and I hope tofollow this up with something that passed Stacked Borrows. Additionallythat'll hopefully make this diff smaller and easier to digest.Given all that, the end result of this PR is to get 131 separate unittests executing on CI. These unit tests largely exercise the embeddingAPI where wasm function compilation is not involved. Some tests compilewasm functions but don't run them, but compiling wasm through Craneliftin MIRI is so slow that it doesn't seem worth it at this time. This doesmean that there's a pretty big hole in MIRI's test coverage, but that'sto be expected as we're a JIT compiler after all.To get tests working in MIRI this PR uses a number of strategies:* When platform-specific code is involved there's now `#[cfg(miri)]` for MIRI's version. For example there's a custom-built "mmap" just for MIRI now. Many of these are simple noops, some are `unimplemented!()` as they shouldn't be reached, and some are slightly nontrivial implementations such as mmaps and trap handling (for native-to-native function calls).* Many test modules are simply excluded via `#![cfg(not(miri))]` at the top of the file. This excludes the entire module's worth of tests from MIRI. Other modules have `#[cfg_attr(miri, ignore)]` annotations to ignore tests by default on MIRI. The latter form is used in modules where some tests work and some don't. This means that all future test additions will need to be effectively annotated whether they work in MIRI or not. My hope though is that there's enough precedent in the test suite of what to do to not cause too much burden.* A number of locations are fixed with respect to MIRI's analysis. For example `ComponentInstance`, the component equivalent of `wasmtime_runtime::Instance`, was actually left out from the fix for the CVE by accident. MIRI dutifully highlighted the issues here and I've fixed them locally. Some locations fixed for MIRI are changed to something that looks similar but is subtly different. For example retaining items in a `Store` is now done with a Wasmtime-specific `StoreBox` type. This is because, with MIRI's analyses, moving a `Box` invalidates all pointers derived from this `Box`. We don't want these semantics, so we effectively have a custom `Box` to suit our needs in this regard.* Some default configuration is different under MIRI. For example most linear memories are dynamic with no guards and no space reserved for growth. Settings such as parallel compilation are disabled. These are applied to make MIRI "work by default" in more places ideally. Some tests which perform N iterations of something perform fewer iterations on MIRI to not take quite so long.This PR is not intended to be a one-and-done-we-never-look-at-it-againkind of thing. Instead this is intended to lay the groundwork tocontinuously run MIRI in CI to catch any soundness issues. This feels,to me, overdue given the amount of `unsafe` code inside of Wasmtime. Myhope is that over time we can figure out how to run Wasm in MIRI butthat may take quite some time. Regardless this will be adding nontrivialmaintenance work to contributors to Wasmtime. MIRI will be run on CI formerges, MIRI will have test failures when everything else passes,MIRI's errors will need to be deciphered by those who have probablynever run MIRI before, things like that. Despite all this to me it seemsworth the cost at this time. Just getting this running caught twopossible soundness bugs in the component implementation that could havehad a real-world impact in the future![stacked]: https://github.com/rust-lang/unsafe-code-guidelines/blob/master/wip/stacked-borrows.md[tree]: https://perso.crans.org/vanille/treebor/[discuss]: https://rust-lang.zulipchat.com/#narrow/stream/269128-miri/topic/Tree.20vs.20Stacked.20Borrows.20.26.20a.20debugging.20question* Update alignment comment List of files: /wasmtime-44.0.1/tests/all/stack_overflow.rs

8bc75502 - wasmtime: enable stack probing for x86_64 targets. (#5350)

Wed, 30 Nov 2022 15:57:53 +0000

wasmtime: enable stack probing for x86_64 targets. (#5350)* wasmtime: enable stack probing for x86_64 targets. This commit unconditionally enables stack probing for x86_64 targets. On Windows, stack probing is always required because of the way Windows commits stack pages (via guard page access). Fixes #5340. * Remove SIMD types from test case. List of files: /wasmtime-44.0.1/tests/all/stack_overflow.rs

b0939f66 - Remove explicit `S` type parameters (#5275)

Wed, 16 Nov 2022 05:04:26 +0000

Remove explicit `S` type parameters (#5275)* Remove explicit `S` type parameters This commit removes the explicit `S` type parameter on `Func::typed` and `Instance::get_typed_func`. Historical versions of Rust required that this be a type parameter but recent rustcs support a mixture of explicit type parameters and `impl Trait`. This removes, at callsites, a superfluous `, _` argument which otherwise never needs specification. * Fix mdbook examples List of files: /wasmtime-44.0.1/tests/all/stack_overflow.rs

2afaac51 - Return `anyhow::Error` from host functions instead of `Trap`, redesign `Trap` (#5149)

Wed, 02 Nov 2022 16:29:31 +0000

Return `anyhow::Error` from host functions instead of `Trap`, redesign `Trap` (#5149)* Return `anyhow::Error` from host functions instead of `Trap` This commit refactors how errors are modeled when returned from host functions and additionally refactors how custom errors work with `Trap`. At a high level functions in Wasmtime that previously worked with `Result` now work with `Result` instead where the error is `anyhow::Error`. This includes functions such as: * Host-defined functions in a `Linker` * `TypedFunc::call` * Host-related callbacks like call hooks Errors are now modeled primarily as `anyhow::Error` throughout Wasmtime. This subsequently removes the need for `Trap` to have the ability to represent all host-defined errors as it previously did. Consequently the `From` implementations for any error into a `Trap` have been removed here and the only embedder-defined way to create a `Trap` is to use `Trap::new` with a custom string. After this commit the distinction between a `Trap` and a host error is the wasm backtrace that it contains. Previously all errors in host functions would flow through a `Trap` and get a wasm backtrace attached to them, but now this only happens if a `Trap` itself is created meaning that arbitrary host-defined errors flowing from a host import to the other side won't get backtraces attached. Some internals of Wasmtime itself were updated or preserved to use `Trap::new` to capture a backtrace where it seemed useful, such as when fuel runs out. The main motivation for this commit is that it now enables hosts to thread a concrete error type from a host function all the way through to where a wasm function was invoked. Previously this could not be done since the host error was wrapped in a `Trap` that didn't provide the ability to get at the internals. A consequence of this commit is that when a host error is returned that isn't a `Trap` we'll capture a backtrace and then won't have a `Trap` to attach it to. To avoid losing the contextual information this commit uses the `Error::context` method to attach the backtrace as contextual information to ensure that the backtrace is itself not lost. This is a breaking change for likely all users of Wasmtime, but it's hoped to be a relatively minor change to workaround. Most use cases can likely change `-> Result` to `-> Result` and otherwise explicit creation of a `Trap` is largely no longer necessary. * Fix some doc links * add some tests and make a backtrace type public (#55) * Trap: avoid a trailing newline in the Display impl which in turn ends up with three newlines between the end of the backtrace and the `Caused by` in the anyhow Debug impl * make BacktraceContext pub, and add tests showing downcasting behavior of anyhow::Error to traps or backtraces * Remove now-unnecesary `Trap` downcasts in `Linker::module` * Fix test output expectations * Remove `Trap::i32_exit` This commit removes special-handling in the `wasmtime::Trap` type for the i32 exit code required by WASI. This is now instead modeled as a specific `I32Exit` error type in the `wasmtime-wasi` crate which is returned by the `proc_exit` hostcall. Embedders which previously tested for i32 exits now downcast to the `I32Exit` value. * Remove the `Trap::new` constructor This commit removes the ability to create a trap with an arbitrary error message. The purpose of this commit is to continue the prior trend of leaning into the `anyhow::Error` type instead of trying to recreate it with `Trap`. A subsequent simplification to `Trap` after this commit is that `Trap` will simply be an `enum` of trap codes with no extra information. This commit is doubly-motivated by the desire to always use the new `BacktraceContext` type instead of sometimes using that and sometimes using `Trap`. Most of the changes here were around updating `Trap::new` calls to `bail!` calls instead. Tests which assert particular error messages additionally often needed to use the `:?` formatter instead of the `{}` formatter because the prior formats the whole `anyhow::Error` and the latter only formats the top-most error, which now contains the backtrace. * Merge `Trap` and `TrapCode` With prior refactorings there's no more need for `Trap` to be opaque or otherwise contain a backtrace. This commit parse down `Trap` to simply an `enum` which was the old `TrapCode`. All various tests and such were updated to handle this. The main consequence of this commit is that all errors have a `BacktraceContext` context attached to them. This unfortunately means that the backtrace is printed first before the error message or trap code, but given all the prior simplifications that seems worth it at this time. * Rename `BacktraceContext` to `WasmBacktrace` This feels like a better name given how this has turned out, and additionally this commit removes having both `WasmBacktrace` and `BacktraceContext`. * Soup up documentation for errors and traps * Fix build of the C API Co-authored-by: Pat Hickey List of files: /wasmtime-44.0.1/tests/all/stack_overflow.rs

aeaca206 - Decrease default wasm stack to 512k from 1M (#3861)

Mon, 28 Feb 2022 18:18:11 +0000

Decrease default wasm stack to 512k from 1M (#3861)This commit aims to achieve the goal of being able to run the test suite on Windows with `--test-threads 1`, or more notably allowing Wasmtime's defaults to work better with the main thread on Windows which appears to have a smaller stack by default than Linux by comparison. In decreasing the default wasm stack size a test is also update to probe for less stack to work on Windows' main thread by default, ideally allowing the full test suite to work with `--test-threads 1` (although this isn't added to CI as it's not really critical). Closes #3857 List of files: /wasmtime-44.0.1/tests/all/stack_overflow.rs

7a1b7cdf - Implement RFC 11: Redesigning Wasmtime's APIs (#2897)

Thu, 03 Jun 2021 14:10:53 +0000

Implement RFC 11: Redesigning Wasmtime's APIs (#2897)Implement Wasmtime's new API as designed by RFC 11. This is quite a large commit which has had lots of discussion externally, so for more information it's best to read the RFC thread and the PR thread. List of files: /wasmtime-44.0.1/tests/all/stack_overflow.rs

2697a18d - Redo the statically typed `Func` API (#2719)

Thu, 11 Mar 2021 20:43:34 +0000

Redo the statically typed `Func` API (#2719)* Redo the statically typed `Func` API This commit reimplements the `Func` API with respect to statically typed dispatch. Previously `Func` had a `getN` and `getN_async` family of methods which were implemented for 0 to 16 parameters. The return value of these functions was an `impl Fn(..)` closure with the appropriate parameters and return values. There are a number of downsides with this approach that have become apparent over time: * The addition of `*_async` doubled the API surface area (which is quite large here due to one-method-per-number-of-parameters). * The [documentation of `Func`][old-docs] are quite verbose and feel "polluted" with all these getters, making it harder to understand the other methods that can be used to interact with a `Func`. * These methods unconditionally pay the cost of returning an owned `impl Fn` with a `'static` lifetime. While cheap, this is still paying the cost for cloning the `Store` effectively and moving data into the closed-over environment. * Storage of the return value into a struct, for example, always requires `Box`-ing the returned closure since it otherwise cannot be named. * Recently I had the desire to implement an "unchecked" path for invoking wasm where you unsafely assert the type signature of a wasm function. Doing this with today's scheme would require doubling (again) the API surface area for both async and synchronous calls, further polluting the documentation. The main benefit of the previous scheme is that by returning a `impl Fn` it was quite easy and ergonomic to actually invoke the function. In practice, though, examples would often have something akin to `.get0::<()>()?()?` which is a lot of things to interpret all at once. Note that `get0` means "0 parameters" yet a type parameter is passed. There's also a double function invocation which looks like a lot of characters all lined up in a row. Overall, I think that the previous design is starting to show too many cracks and deserves a rewrite. This commit is that rewrite. The new design in this commit is to delete the `getN{,_async}` family of functions and instead have a new API: impl Func { fn typed(&self) -> Result<&Typed>; } impl Typed { fn call(&self, params: P) -> Result; async fn call_async(&self, params: P) -> Result; } This should entirely replace the current scheme, albeit by slightly losing ergonomics use cases. The idea behind the API is that the existence of `Typed` is a "proof" that the underlying function takes `P` and returns `R`. The `Func::typed` method peforms a runtime type-check to ensure that types all match up, and if successful you get a `Typed` value. Otherwise an error is returned. Once you have a `Typed` then, like `Func`, you can either `call` or `call_async`. The difference with a `Typed`, however, is that the params/results are statically known and hence these calls can be much more efficient. This is a much smaller API surface area from before and should greatly simplify the `Func` documentation. There's still a problem where `Func::wrapN_async` produces a lot of functions to document, but that's now the sole offender. It's a nice benefit that the statically-typed-async verisons are now expressed with an `async` function rather than a function-returning-a-future which makes it both more efficient and easier to understand. The type `P` and `R` are intended to either be bare types (e.g. `i32`) or tuples of any length (including 0). At this time `R` is only allowed to be `()` or a bare `i32`-style type because multi-value is not supported with a native ABI (yet). The `P`, however, can be any size of tuples of parameters. This is also where some ergonomics are lost because instead of `f(1, 2)` you now have to write `f.call((1, 2))` (note the double-parens). Similarly `f()` becomes `f.call(())`. Overall I feel that this is a better tradeoff than before. While not universally better due to the loss in ergonomics I feel that this design is much more flexible in terms of what you can do with the return value and also understanding the API surface area (just less to take in). [old-docs]: https://docs.rs/wasmtime/0.24.0/wasmtime/struct.Func.html#method.get0 * Rename Typed to TypedFunc * Implement multi-value returns through `Func::typed` * Fix examples in docs * Fix some more errors * More test fixes * Rebasing and adding `get_typed_func` * Updating tests * Fix typo * More doc tweaks * Tweak visibility on `Func::invoke` * Fix tests again List of files: /wasmtime-44.0.1/tests/all/stack_overflow.rs

4f7bec5e - machinst x64: enable two more Rust tests;

Thu, 24 Sep 2020 15:37:48 +0000

machinst x64: enable two more Rust tests;Fixed by the grand ABI refactoring, h/t @cfallin. List of files: /wasmtime-44.0.1/tests/all/stack_overflow.rs

79abcdb0 - machinst x64: add testing to the CI;

Wed, 29 Jul 2020 16:08:35 +0000

machinst x64: add testing to the CI; List of files: /wasmtime-44.0.1/tests/all/stack_overflow.rs

15c68f2c - Disconnects `Store` state fields from `Compiler` (#1761)

Tue, 02 Jun 2020 18:44:39 +0000

Disconnects `Store` state fields from `Compiler` (#1761)* Moves CodeMemory, VMInterrupts and SignatureRegistry from Compiler * CompiledModule holds CodeMemory and GdbJitImageRegistration * Store keeps track of its JIT code * Makes "jit_int.rs" stuff Send+Sync * Adds the threads example. List of files: /wasmtime-44.0.1/tests/all/stack_overflow.rs

fb0b9e3a - Change `proc_exit` to unwind the stack rather than exiting the host process. (#1646)

Wed, 13 May 2020 22:59:43 +0000

Change `proc_exit` to unwind the stack rather than exiting the host process. (#1646)* Remove Cranelift's OutOfBounds trap, which is no longer used. * Change proc_exit to unwind instead of exit the host process. This implements the semantics in https://github.com/WebAssembly/WASI/pull/235. Fixes #783. Fixes #993. * Fix exit-status tests on Windows. * Revert the wiggle changes and re-introduce the wasi-common implementations. * Move `wasi_proc_exit` into the wasmtime-wasi crate. * Revert the spec_testsuite change. * Remove the old proc_exit implementations. * Make `TrapReason` an implementation detail. * Allow exit status 2 on Windows too. * Fix a documentation link. * Really fix a documentation link. List of files: /wasmtime-44.0.1/tests/all/stack_overflow.rs