wasmer_types/
error.rs

1//! The WebAssembly possible errors
2use crate::{ExternType, Pages, progress::UserAbort};
3use std::io;
4use thiserror::Error;
5
6/// The Serialize error can occur when serializing a
7/// compiled Module into a binary.
8#[derive(Error, Debug)]
9pub enum SerializeError {
10    /// An IO error
11    #[error(transparent)]
12    Io(#[from] io::Error),
13    /// A generic serialization error
14    #[error("{0}")]
15    Generic(String),
16}
17
18/// The Deserialize error can occur when loading a
19/// compiled Module from a binary.
20#[derive(Error, Debug)]
21pub enum DeserializeError {
22    /// An IO error
23    #[error(transparent)]
24    Io(#[from] io::Error),
25    /// A generic deserialization error
26    #[error("{0}")]
27    Generic(String),
28    /// Incompatible serialized binary
29    #[error("incompatible binary: {0}")]
30    Incompatible(String),
31    /// The provided binary is corrupted
32    #[error("corrupted binary: {0}")]
33    CorruptedBinary(String),
34    /// The binary was valid, but we got an error when
35    /// trying to allocate the required resources.
36    #[error(transparent)]
37    Compiler(#[from] CompileError),
38    /// Input artifact bytes have an invalid length
39    #[error("invalid input bytes: expected {expected} bytes, got {got}")]
40    InvalidByteLength {
41        /// How many bytes were expected
42        expected: usize,
43        /// How many bytes the artifact contained
44        got: usize,
45    },
46}
47
48/// Error type describing things that can go wrong when operating on Wasm Memories.
49#[derive(Error, Debug, Clone, PartialEq, Eq, Hash)]
50#[non_exhaustive]
51pub enum MemoryError {
52    /// Low level error with mmap.
53    #[error("Error when allocating memory: {0}")]
54    Region(String),
55    /// The operation would cause the size of the memory to exceed the maximum or would cause
56    /// an overflow leading to unindexable memory.
57    #[error("The memory could not grow: current size {} pages, requested increase: {} pages", current.0, attempted_delta.0)]
58    CouldNotGrow {
59        /// The current size in pages.
60        current: Pages,
61        /// The attempted amount to grow by in pages.
62        attempted_delta: Pages,
63    },
64    /// Invalid memory was provided.
65    #[error("The memory is invalid because {}", reason)]
66    InvalidMemory {
67        /// The reason why the provided memory is invalid.
68        reason: String,
69    },
70    /// Caller asked for more minimum memory than we can give them.
71    #[error("The minimum requested ({} pages) memory is greater than the maximum allowed memory ({} pages)", min_requested.0, max_allowed.0)]
72    MinimumMemoryTooLarge {
73        /// The number of pages requested as the minimum amount of memory.
74        min_requested: Pages,
75        /// The maximum amount of memory we can allocate.
76        max_allowed: Pages,
77    },
78    /// Caller asked for a maximum memory greater than we can give them.
79    #[error("The maximum requested memory ({} pages) is greater than the maximum allowed memory ({} pages)", max_requested.0, max_allowed.0)]
80    MaximumMemoryTooLarge {
81        /// The number of pages requested as the maximum amount of memory.
82        max_requested: Pages,
83        /// The number of pages requested as the maximum amount of memory.
84        max_allowed: Pages,
85    },
86    /// Returned when a shared memory is required, but the given memory is not shared.
87    #[error("The memory is not shared")]
88    MemoryNotShared,
89    /// Returned when trying to call a memory operation that is not supported by
90    /// the particular memory implementation.
91    #[error("tried to call an unsupported memory operation: {message}")]
92    UnsupportedOperation {
93        /// Message describing the unsupported operation.
94        message: String,
95    },
96    /// The memory does not support atomic operations.
97    #[error("The memory does not support atomic operations")]
98    AtomicsNotSupported,
99    /// A user defined error value, used for error cases not listed above.
100    #[error("A user-defined error occurred: {0}")]
101    Generic(String),
102}
103
104/// An ImportError.
105///
106/// Note: this error is not standard to WebAssembly, but it's
107/// useful to determine the import issue on the API side.
108#[derive(Error, Debug, Clone)]
109pub enum ImportError {
110    /// Incompatible Import Type.
111    /// This error occurs when the import types mismatch.
112    #[error("incompatible import type. Expected {0:?} but received {1:?}")]
113    IncompatibleType(ExternType, ExternType),
114
115    /// Unknown Import.
116    /// This error occurs when an import was expected but not provided.
117    #[error("unknown import. Expected {0:?}")]
118    UnknownImport(ExternType),
119
120    /// Memory Error
121    #[error("memory error. {0}")]
122    MemoryError(String),
123}
124
125/// An error while preinstantiating a module.
126///
127#[derive(Error, Debug)]
128pub enum PreInstantiationError {
129    /// The module was compiled with a CPU feature that is not available on
130    /// the current host.
131    #[error("module compiled with CPU feature that is missing from host")]
132    CpuFeature(String),
133}
134
135use crate::lib::std::string::String;
136
137// Compilation Errors
138//
139// If `std` feature is enable, we can't use `thiserror` until
140// https://github.com/dtolnay/thiserror/pull/64 is merged.
141
142/// The WebAssembly.CompileError object indicates an error during
143/// WebAssembly decoding or validation.
144///
145/// This mirrors the WebAssembly `CompileError` API described at
146/// <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/CompileError>.
147#[derive(Debug)]
148#[cfg_attr(feature = "std", derive(Error))]
149pub enum CompileError {
150    /// A Wasm translation error occurred.
151    #[cfg_attr(feature = "std", error("WebAssembly translation error: {0}"))]
152    Wasm(WasmError),
153
154    /// A compilation error occurred.
155    #[cfg_attr(feature = "std", error("Compilation error: {0}"))]
156    Codegen(String),
157
158    /// The module did not pass validation.
159    #[cfg_attr(feature = "std", error("Validation error: {0}"))]
160    Validate(String),
161
162    /// The compiler doesn't support a Wasm feature
163    #[cfg_attr(feature = "std", error("Feature {0} is not yet supported"))]
164    UnsupportedFeature(String),
165
166    /// The compiler cannot compile for the given target.
167    /// This can refer to the OS, the chipset or any other aspect of the target system.
168    #[cfg_attr(
169        feature = "std",
170        error("The target {0} is not yet supported (see https://docs.wasmer.io/runtime/features)")
171    )]
172    UnsupportedTarget(String),
173
174    /// Insufficient resources available for execution.
175    #[cfg_attr(feature = "std", error("Insufficient resources: {0}"))]
176    Resource(String),
177
178    /// Middleware error occurred.
179    #[cfg_attr(feature = "std", error("Middleware error: {0}"))]
180    MiddlewareError(String),
181
182    /// Compilation aborted by a user callback.
183    #[cfg_attr(feature = "std", error("Compilation aborted: {0}"))]
184    Aborted(UserAbort),
185}
186
187impl From<WasmError> for CompileError {
188    fn from(original: WasmError) -> Self {
189        Self::Wasm(original)
190    }
191}
192
193impl From<UserAbort> for CompileError {
194    fn from(abort: UserAbort) -> Self {
195        Self::Aborted(abort)
196    }
197}
198
199/// A error in the middleware.
200#[derive(Debug)]
201#[cfg_attr(feature = "std", derive(Error))]
202#[cfg_attr(feature = "std", error("Error in middleware {name}: {message}"))]
203pub struct MiddlewareError {
204    /// The name of the middleware where the error was created
205    pub name: String,
206    /// The error message
207    pub message: String,
208}
209
210impl MiddlewareError {
211    /// Create a new `MiddlewareError`
212    pub fn new<A: Into<String>, B: Into<String>>(name: A, message: B) -> Self {
213        Self {
214            name: name.into(),
215            message: message.into(),
216        }
217    }
218}
219
220impl From<MiddlewareError> for CompileError {
221    fn from(error: MiddlewareError) -> Self {
222        WasmError::Middleware(error).into()
223    }
224}
225
226/// A WebAssembly translation error.
227///
228/// When a WebAssembly function can't be translated, one of these error codes will be returned
229/// to describe the failure.
230#[derive(Debug)]
231#[cfg_attr(feature = "std", derive(Error))]
232pub enum WasmError {
233    /// The input WebAssembly code is invalid.
234    ///
235    /// This error code is used by a WebAssembly translator when it encounters invalid WebAssembly
236    /// code. This should never happen for validated WebAssembly code.
237    #[cfg_attr(
238        feature = "std",
239        error("Invalid input WebAssembly code at offset {offset}: {message}")
240    )]
241    InvalidWebAssembly {
242        /// A string describing the validation error.
243        message: String,
244        /// The bytecode offset where the error occurred.
245        offset: usize,
246    },
247
248    /// A feature used by the WebAssembly code is not supported by the embedding environment.
249    ///
250    /// Embedding environments may have their own limitations and feature restrictions.
251    #[cfg_attr(feature = "std", error("Unsupported feature: {0}"))]
252    Unsupported(String),
253
254    /// An implementation limit was exceeded.
255    #[cfg_attr(feature = "std", error("Implementation limit exceeded"))]
256    ImplLimitExceeded,
257
258    /// An error from the middleware error.
259    #[cfg_attr(feature = "std", error("{0}"))]
260    Middleware(MiddlewareError),
261
262    /// A generic error.
263    #[cfg_attr(feature = "std", error("{0}"))]
264    Generic(String),
265}
266
267impl From<MiddlewareError> for WasmError {
268    fn from(original: MiddlewareError) -> Self {
269        Self::Middleware(original)
270    }
271}
272
273/// The error that can happen while parsing a `str`
274/// to retrieve a [`CpuFeature`](crate::target::CpuFeature).
275#[derive(Debug)]
276#[cfg_attr(feature = "std", derive(Error))]
277pub enum ParseCpuFeatureError {
278    /// The provided string feature doesn't exist
279    #[cfg_attr(feature = "std", error("CpuFeature {0} not recognized"))]
280    Missing(String),
281}
282
283/// A convenient alias for a `Result` that uses `WasmError` as the error type.
284pub type WasmResult<T> = Result<T, WasmError>;
285
286#[cfg(test)]
287mod tests {
288    use super::*;
289
290    #[test]
291    fn middleware_error_can_be_created() {
292        let msg = String::from("Something went wrong");
293        let error = MiddlewareError::new("manipulator3000", msg);
294        assert_eq!(error.name, "manipulator3000");
295        assert_eq!(error.message, "Something went wrong");
296    }
297
298    #[test]
299    fn middleware_error_be_converted_to_wasm_error() {
300        let error = WasmError::from(MiddlewareError::new("manipulator3000", "foo"));
301        match error {
302            WasmError::Middleware(MiddlewareError { name, message }) => {
303                assert_eq!(name, "manipulator3000");
304                assert_eq!(message, "foo");
305            }
306            err => panic!("Unexpected error: {err:?}"),
307        }
308    }
309}
wasmer_types/error.rs

wasmer_types/
error.rs
