Merge vcode filetest mode into compile.

I hadn't realized before that the filetest backend for `test vcode` is
doing essentially what `compile` is doing, but for new (`MachInst`)
backends: it is just getting a disassembly and running it through
filecheck. There's no reason not to reuse `test compile` for the AArch64
tests as well.

This was motivated by the desire to have "this IR compiles successfully"
tests work on both x86 and AArch64. It seems this should work fine by
adding multiple `target` directives when a test case should be
compile-tested on multiple architectures.

cranelift/filetests/src/test_compile.rs

@@ -40,6 +40,11 @@ impl SubTest for TestCompile {
         let isa = context.isa.expect("compile needs an ISA");
         let mut comp_ctx = cranelift_codegen::Context::for_function(func.into_owned());
 
+        if isa.get_mach_backend().is_some() {
+            // With `MachBackend`s, we need to explicitly request dissassembly results.
+            comp_ctx.set_disasm(true);
+        }
+
         let CodeInfo { total_size, .. } = comp_ctx
             .compile(isa)
             .map_err(|e| pretty_error(&comp_ctx.func, context.isa, e))?;
@@ -50,25 +55,36 @@ impl SubTest for TestCompile {
             comp_ctx.func.display(isa)
         );
 
-        // Verify that the returned code size matches the emitted bytes.
-        let mut sink = SizeSink { offset: 0 };
-        binemit::emit_function(
-            &comp_ctx.func,
-            |func, inst, div, sink, isa| isa.emit_inst(func, inst, div, sink),
-            &mut sink,
-            isa,
-        );
+        if !isa.get_mach_backend().is_some() {
+            // Verify that the returned code size matches the emitted bytes.
+            let mut sink = SizeSink { offset: 0 };
+            binemit::emit_function(
+                &comp_ctx.func,
+                |func, inst, div, sink, isa| isa.emit_inst(func, inst, div, sink),
+                &mut sink,
+                isa,
+            );
 
-        if sink.offset != total_size {
-            return Err(format!(
-                "Expected code size {}, got {}",
-                total_size, sink.offset
-            ));
+            if sink.offset != total_size {
+                return Err(format!(
+                    "Expected code size {}, got {}",
+                    total_size, sink.offset
+                ));
+            }
+
+            // Run final code through filecheck.
+            let text = comp_ctx.func.display(Some(isa)).to_string();
+            run_filecheck(&text, context)
+        } else {
+            let disasm = comp_ctx
+                .mach_compile_result
+                .as_ref()
+                .unwrap()
+                .disasm
+                .as_ref()
+                .unwrap();
+            run_filecheck(&disasm, context)
         }
-
-        // Run final code through filecheck.
-        let text = comp_ctx.func.display(Some(isa)).to_string();
-        run_filecheck(&text, context)
     }
 }