0c7316ae28
* Replace a single-character string literal with a character literal. * Use is_some() instead of comparing with Some(_). * Add code-quotes around type names in comments. * Use !...is_empty() instead of len() != 0. * Tidy up redundant returns. * Remove redundant .clone() calls. * Remove unnecessary explicit lifetime parameters. * Tidy up unnecessary '&'s. * Add parens to make operator precedence explicit. * Use debug_assert_eq instead of debug_assert with ==. * Replace a &Vec argument with a &[...]. * Replace `a = a op b` with `a op= b`. * Avoid unnecessary closures. * Avoid .iter() and .iter_mut() for iterating over containers. * Remove unneeded qualification.
68 lines
2.1 KiB
Rust
68 lines
2.1 KiB
Rust
//! Result and error types representing the outcome of compiling a function.
|
|
|
|
use verifier;
|
|
use std::error::Error as StdError;
|
|
use std::fmt;
|
|
|
|
/// A compilation error.
|
|
///
|
|
/// When Cretonne fails to compile a function, it will return one of these error codes.
|
|
#[derive(Debug)]
|
|
pub enum CtonError {
|
|
/// An IL verifier error.
|
|
///
|
|
/// This always represents a bug, either in the code that generated IL for Cretonne, or a bug
|
|
/// in Cretonne itself.
|
|
Verifier(verifier::Error),
|
|
|
|
/// An implementation limit was exceeded.
|
|
///
|
|
/// Cretonne can compile very large and complicated functions, but the implementation has
|
|
/// limits that cause compilation to fail when they are exceeded.
|
|
///
|
|
/// See http://cretonne.readthedocs.io/en/latest/langref.html#implementation-limits
|
|
ImplLimitExceeded,
|
|
|
|
/// The code size for the function is too large.
|
|
///
|
|
/// Different target ISAs may impose a limit on the size of a compiled function. If that limit
|
|
/// is exceeded, compilation fails.
|
|
CodeTooLarge,
|
|
}
|
|
|
|
/// A Cretonne compilation result.
|
|
pub type CtonResult = Result<(), CtonError>;
|
|
|
|
impl fmt::Display for CtonError {
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
|
match *self {
|
|
CtonError::Verifier(ref e) => write!(f, "Verifier error: {}", e),
|
|
CtonError::ImplLimitExceeded |
|
|
CtonError::CodeTooLarge => f.write_str(self.description()),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl StdError for CtonError {
|
|
fn description(&self) -> &str {
|
|
match *self {
|
|
CtonError::Verifier(ref e) => &e.message,
|
|
CtonError::ImplLimitExceeded => "Implementation limit exceeded",
|
|
CtonError::CodeTooLarge => "Code for function is too large",
|
|
}
|
|
}
|
|
fn cause(&self) -> Option<&StdError> {
|
|
match *self {
|
|
CtonError::Verifier(ref e) => Some(e),
|
|
CtonError::ImplLimitExceeded |
|
|
CtonError::CodeTooLarge => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<verifier::Error> for CtonError {
|
|
fn from(e: verifier::Error) -> CtonError {
|
|
CtonError::Verifier(e)
|
|
}
|
|
}
|