Print return values of run tests if type is not boolean.

cranelift-filetests/src/lib.rs

@@ -24,6 +24,7 @@
 )]
 
 pub use crate::function_runner::FunctionRunner;
+pub use crate::function_runner::FunctionRunnerBuilder;
 use crate::runner::TestRunner;
 use cranelift_codegen::timing;
 use cranelift_reader::TestCommand;

cranelift-filetests/src/test_run.rs

@@ -2,7 +2,7 @@
 //!
 //! The `run` test command compiles each function on the host machine and executes it
 
-use crate::function_runner::FunctionRunner;
+use crate::function_runner::FunctionRunnerBuilder;
 use crate::subtest::{Context, SubTest, SubtestResult};
 use cranelift_codegen;
 use cranelift_codegen::ir;
@@ -36,8 +36,10 @@ impl SubTest for TestRun {
     fn run(&self, func: Cow<ir::Function>, context: &Context) -> SubtestResult<()> {
         for comment in context.details.comments.iter() {
             if comment.text.contains("run") {
-                let runner =
-                    FunctionRunner::with_host_isa(func.clone().into_owned(), context.flags.clone());
+                let runner = FunctionRunnerBuilder::new(func.clone().into_owned())
+                    .with_host_isa(context.flags.clone())
+                    .with_action_text(comment.text)
+                    .finish();
                 runner.run()?
             }
         }

cranelift-reader/src/lib.rs

@@ -28,7 +28,7 @@
 
 pub use crate::error::{Location, ParseError, ParseResult};
 pub use crate::isaspec::{parse_options, IsaSpec};
-pub use crate::parser::{parse_functions, parse_test, ParseOptions};
+pub use crate::parser::{parse_functions, parse_test, ParseOptions, Parser};
 pub use crate::sourcemap::SourceMap;
 pub use crate::testcommand::{TestCommand, TestOption};
 pub use crate::testfile::{Comment, Details, Feature, TestFile};

cranelift-reader/src/parser.rs

@@ -110,6 +110,7 @@ pub fn parse_test<'a>(text: &'a str, options: ParseOptions<'a>) -> ParseResult<T
     })
 }
 
+/// Parser for .clif files.
 pub struct Parser<'a> {
     lex: Lexer<'a>,
 
@@ -609,8 +610,8 @@ impl<'a> Parser<'a> {
         }
     }
 
-    // Match and consume either a hexadecimal Uimm128 immediate (e.g. 0x000102...) or its literal list form (e.g. [0 1 2...])
-    fn match_constant_data(&mut self, controlling_type: Type) -> ParseResult<ConstantData> {
+    /// Match and consume either a hexadecimal Uimm128 immediate (e.g. 0x000102...) or its literal list form (e.g. [0 1 2...])
+    pub fn match_constant_data(&mut self, controlling_type: Type) -> ParseResult<ConstantData> {
         let expected_size = controlling_type.bytes() as usize;
         let constant_data = if self.optional(Token::LBracket) {
             // parse using a list of values, e.g. vconst.i32x4 [0 1 2 3]
@@ -634,8 +635,8 @@ impl<'a> Parser<'a> {
         }
     }
 
-    // Match and consume a Uimm64 immediate.
-    fn match_uimm64(&mut self, err_msg: &str) -> ParseResult<Uimm64> {
+    /// Match and consume a Uimm64 immediate.
+    pub fn match_uimm64(&mut self, err_msg: &str) -> ParseResult<Uimm64> {
         if let Some(Token::Integer(text)) = self.token() {
             self.consume();
             // Lexer just gives us raw text that looks like an integer.
@@ -647,8 +648,8 @@ impl<'a> Parser<'a> {
         }
     }
 
-    // Match and consume a Uimm32 immediate.
-    fn match_uimm32(&mut self, err_msg: &str) -> ParseResult<Uimm32> {
+    /// Match and consume a Uimm32 immediate.
+    pub fn match_uimm32(&mut self, err_msg: &str) -> ParseResult<Uimm32> {
         if let Some(Token::Integer(text)) = self.token() {
             self.consume();
             // Lexer just gives us raw text that looks like an integer.
@@ -659,9 +660,9 @@ impl<'a> Parser<'a> {
         }
     }
 
-    // Match and consume a u8 immediate.
     // This is used for lane numbers in SIMD vectors.
-    fn match_uimm8(&mut self, err_msg: &str) -> ParseResult<u8> {
+    /// Match and consume a u8 immediate.
+    pub fn match_uimm8(&mut self, err_msg: &str) -> ParseResult<u8> {
         if let Some(Token::Integer(text)) = self.token() {
             self.consume();
             // Lexer just gives us raw text that looks like an integer.
@@ -740,8 +741,8 @@ impl<'a> Parser<'a> {
         Ok(Imm64::new(0))
     }
 
-    // Match and consume an Ieee32 immediate.
-    fn match_ieee32(&mut self, err_msg: &str) -> ParseResult<Ieee32> {
+    /// Match and consume an Ieee32 immediate.
+    pub fn match_ieee32(&mut self, err_msg: &str) -> ParseResult<Ieee32> {
         if let Some(Token::Float(text)) = self.token() {
             self.consume();
             // Lexer just gives us raw text that looks like a float.
@@ -752,8 +753,8 @@ impl<'a> Parser<'a> {
         }
     }
 
-    // Match and consume an Ieee64 immediate.
-    fn match_ieee64(&mut self, err_msg: &str) -> ParseResult<Ieee64> {
+    /// Match and consume an Ieee64 immediate.
+    pub fn match_ieee64(&mut self, err_msg: &str) -> ParseResult<Ieee64> {
         if let Some(Token::Float(text)) = self.token() {
             self.consume();
             // Lexer just gives us raw text that looks like a float.
@@ -764,8 +765,8 @@ impl<'a> Parser<'a> {
         }
     }
 
-    // Match and consume a boolean immediate.
-    fn match_bool(&mut self, err_msg: &str) -> ParseResult<bool> {
+    /// Match and consume a boolean immediate.
+    pub fn match_bool(&mut self, err_msg: &str) -> ParseResult<bool> {
         if let Some(Token::Identifier(text)) = self.token() {
             self.consume();
             match text {

docs/testing.rst

@@ -397,3 +397,31 @@ Example::
         return v0
     }
     ; run
+
+To print the return value of the function and fail, add a ``; run: print`` directive
+after each function. This is for debugging only.
+
+Example::
+
+    test run
+
+    function %trivial_test() -> i16 {
+    ebb0:
+        v0 = iconst.i16 42
+        return v0
+    }
+    ; run: print
+
+To assert on the return value of the function, add a ``; run: %fn() <op> <expected>`` directive
+after a function. Equality "==" and inequality "!=" operators are supported.
+
+Example::
+
+    test run
+
+    function %trivial_test() -> i16 {
+    ebb0:
+        v0 = iconst.i16 42
+        return v0
+    }
+    ; run: %fn() == 0x2a

filetests/function_runner/basic.clif

@@ -0,0 +1,18 @@
+test run
+target x86_64
+
+function %test_assert_equal() -> i64 {
+ebb0:
+    v0 = iconst.i64 42
+    return v0
+}
+
+;  run:  %fn()    == 0x2a
+
+function %test_assert_inequal() -> i64 {
+ebb0:
+    v0 = iconst.i64 0
+    return v0
+}
+
+; run: %fn() !=  0x2a

filetests/function_runner/types.clif

@@ -0,0 +1,89 @@
+test run
+target x86_64
+
+function %test_i8() -> i8 {
+ebb0:
+    v0 = iconst.i8 42
+    return v0
+}
+; run: %fn() == 0x2a
+
+function %test_i16() -> i16 {
+ebb0:
+    v0 = iconst.i16 42
+    return v0
+}
+; run: %fn() == 0x2a
+
+function %test_i32() -> i32 {
+ebb0:
+    v0 = iconst.i32 42
+    return v0
+}
+; run: %fn() == 0x2a
+
+function %test_i64() -> i64 {
+ebb0:
+    v0 = iconst.i64 0x4242_3535_1234_5678
+    return v0
+}
+; run: %fn() == 0x4242_3535_1234_5678
+
+; Multi-value return does not work on Windows ABI, for details see #1279.
+; function %test_i128() -> i128 {
+; ebb0:
+;     v0 = iconst.i64 0x4242_3535_1234_5678
+;     v1 = iconst.i64 0xabcd_ef01_beef_b411
+;     v2 = iconcat v0, v1
+;     return v2
+; }
+; ; r-u-n: %fn() == 0x4242_3535_1234_5678_abcd_ef01_beef_b411
+
+function %test_b1() -> b1 {
+ebb0:
+    v0 = bconst.b1 true
+    return v0
+}
+; run: %fn() == true
+
+function %test_b8() -> b8 {
+ebb0:
+    v0 = bconst.b8 true
+    return v0
+}
+; run: %fn() == true
+
+function %test_b16() -> b16 {
+ebb0:
+    v0 = bconst.b16 true
+    return v0
+}
+; run: %fn() == true
+
+function %test_b32() -> b32 {
+ebb0:
+    v0 = bconst.b32 true
+    return v0
+}
+; run: %fn() == true
+
+function %test_b64() -> b64 {
+ebb0:
+    v0 = bconst.b64 true
+    return v0
+}
+; run: %fn() == true
+
+function %test_f32() -> f32 {
+ebb0:
+    v0 = f32const 0x1.23
+    return v0
+}
+; run: %fn() == 0x1.23
+
+function %test_f64() -> f64 {
+ebb0:
+    v0 = f64const 0x1000.0001
+    return v0
+}
+; run: %fn() == 0x1000.0001

src/run.rs

@@ -2,7 +2,7 @@
 
 use crate::utils::read_to_string;
 use cranelift_codegen::isa::{CallConv, TargetIsa};
-use cranelift_filetests::FunctionRunner;
+use cranelift_filetests::FunctionRunnerBuilder;
 use cranelift_native::builder as host_isa_builder;
 use cranelift_reader::{parse_test, Details, IsaSpec, ParseOptions};
 use std::path::PathBuf;
@@ -81,9 +81,14 @@ fn run_file_contents(file_contents: String) -> Result<(), String> {
     };
     let test_file = parse_test(&file_contents, options).map_err(|e| e.to_string())?;
     for (func, Details { comments, .. }) in test_file.functions {
-        if comments.iter().any(|c| c.text.contains("run")) {
+        let comment = comments.iter().find(|c| c.text.contains("run"));
+        if let Some(c) = comment {
             let isa = create_target_isa(&test_file.isa_spec)?;
-            FunctionRunner::new(func, isa).run()?
+            let runner = FunctionRunnerBuilder::new(func)
+                .with_isa(isa)
+                .with_action_text(c.text)
+                .finish();
+            runner.run()?
         }
     }
     Ok(())