Add global CtonResult and CtonError types.

These are for reporting the overall result of compiling a function.

lib/cretonne/src/lib.rs

@@ -21,6 +21,7 @@ pub mod flowgraph;
 pub mod ir;
 pub mod isa;
 pub mod regalloc;
+pub mod result;
 pub mod settings;
 pub mod sparse_map;
 pub mod verifier;

lib/cretonne/src/result.rs

@@ -0,0 +1,68 @@
+//! Result and error types representing the outcome of compiling a function.
+
+use verifier;
+use std::error::Error as StdError;
+use std::fmt;
+use std::result;
+
+/// 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::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)
+    }
+}

lib/cretonne/src/verifier/mod.rs

@@ -59,6 +59,7 @@ use ir::instructions::{InstructionFormat, BranchInfo, ResolvedConstraint, CallIn
 use ir::{types, Function, ValueDef, Ebb, Inst, SigRef, FuncRef, ValueList, JumpTable, StackSlot,
          Value, Type};
 use Context;
+use std::error as std_error;
 use std::fmt::{self, Display, Formatter};
 use std::result;
 use std::collections::BTreeSet;
@@ -78,6 +79,12 @@ impl Display for Error {
     }
 }
 
+impl std_error::Error for Error {
+    fn description(&self) -> &str {
+        &self.message
+    }
+}
+
 /// Verifier result.
 pub type Result<T> = result::Result<T, Error>;