diff --git a/cranelift/src/filetest/legalizer.rs b/cranelift/src/filetest/legalizer.rs
index 1a5f774664..c6e08ffe29 100644
--- a/cranelift/src/filetest/legalizer.rs
+++ b/cranelift/src/filetest/legalizer.rs
@@ -8,7 +8,7 @@ use cretonne::{self, write_function};
 use cretonne::ir::Function;
 use cton_reader::TestCommand;
 use filetest::subtest::{SubTest, Context, Result, run_filecheck};
-use utils::pretty_verifier_error;
+use utils::pretty_error;
 
 struct TestLegalizer;
 
@@ -40,9 +40,8 @@ impl SubTest for TestLegalizer {
         let isa = context.isa.expect("legalizer needs an ISA");
 
         comp_ctx.flowgraph();
-        comp_ctx.legalize(isa);
-        comp_ctx.verify(isa)
-            .map_err(|e| pretty_verifier_error(&comp_ctx.func, e))?;
+        comp_ctx.legalize(isa)
+            .map_err(|e| pretty_error(&comp_ctx.func, e))?;
 
         let mut text = String::new();
         write_function(&mut text, &comp_ctx.func, Some(isa)).map_err(|e| e.to_string())?;
diff --git a/cranelift/src/filetest/regalloc.rs b/cranelift/src/filetest/regalloc.rs
index daf7adcb07..87045eb764 100644
--- a/cranelift/src/filetest/regalloc.rs
+++ b/cranelift/src/filetest/regalloc.rs
@@ -10,7 +10,7 @@ use cretonne::{self, write_function};
 use cton_reader::TestCommand;
 use filetest::subtest::{SubTest, Context, Result, run_filecheck};
 use std::borrow::Cow;
-use utils::pretty_verifier_error;
+use utils::pretty_error;
 
 struct TestRegalloc;
 
@@ -45,10 +45,10 @@ impl SubTest for TestRegalloc {
 
         comp_ctx.flowgraph();
         // TODO: Should we have an option to skip legalization?
-        comp_ctx.legalize(isa);
-        comp_ctx.regalloc(isa);
-        comp_ctx.verify(isa)
-            .map_err(|e| pretty_verifier_error(&comp_ctx.func, e))?;
+        comp_ctx.legalize(isa)
+            .map_err(|e| pretty_error(&comp_ctx.func, e))?;
+        comp_ctx.regalloc(isa)
+            .map_err(|e| pretty_error(&comp_ctx.func, e))?;
 
         let mut text = String::new();
         write_function(&mut text, &comp_ctx.func, Some(isa)).map_err(|e| e.to_string())?;
diff --git a/cranelift/src/utils.rs b/cranelift/src/utils.rs
index d2a6fae3c7..3519c55627 100644
--- a/cranelift/src/utils.rs
+++ b/cranelift/src/utils.rs
@@ -2,6 +2,7 @@
 
 use cretonne::ir::entities::AnyEntity;
 use cretonne::{ir, verifier, write_function};
+use cretonne::result::CtonError;
 use std::fmt::Write;
 use std::fs::File;
 use std::io::{Result, Read};
@@ -45,6 +46,15 @@ pub fn pretty_verifier_error(func: &ir::Function, err: verifier::Error) -> Strin
     msg
 }
 
+/// Pretty-print a Cretonne error.
+pub fn pretty_error(func: &ir::Function, err: CtonError) -> String {
+    if let CtonError::Verifier(e) = err {
+        pretty_verifier_error(func, e)
+    } else {
+        err.to_string()
+    }
+}
+
 #[test]
 fn test_match_directive() {
     assert_eq!(match_directive("; foo: bar  ", "foo:"), Some("bar"));
diff --git a/lib/cretonne/src/context.rs b/lib/cretonne/src/context.rs
index 680ddbffeb..71dfa4539b 100644
--- a/lib/cretonne/src/context.rs
+++ b/lib/cretonne/src/context.rs
@@ -15,6 +15,7 @@ use ir::Function;
 use isa::TargetIsa;
 use legalize_function;
 use regalloc;
+use result::CtonResult;
 use verifier;
 
 /// Persistent data structures and compilation pipeline.
@@ -56,9 +57,19 @@ impl Context {
         verifier::verify_context(self)
     }
 
+    /// Run the verifier only if the `enable_verifier` setting is true.
+    pub fn verify_if(&self, isa: &TargetIsa) -> CtonResult {
+        if isa.flags().enable_verifier() {
+            self.verify(isa).map_err(Into::into)
+        } else {
+            Ok(())
+        }
+    }
+
     /// Run the legalizer for `isa` on the function.
-    pub fn legalize(&mut self, isa: &TargetIsa) {
+    pub fn legalize(&mut self, isa: &TargetIsa) -> CtonResult {
         legalize_function(&mut self.func, &mut self.cfg, isa);
+        self.verify_if(isa)
     }
 
     /// Recompute the control flow graph and dominator tree.
@@ -68,8 +79,9 @@ impl Context {
     }
 
     /// Run the register allocator.
-    pub fn regalloc(&mut self, isa: &TargetIsa) {
+    pub fn regalloc(&mut self, isa: &TargetIsa) -> CtonResult {
         self.regalloc
             .run(isa, &mut self.func, &self.cfg, &self.domtree);
+        self.verify_if(isa)
     }
 }