[llvm-exegesis] Run unit tests on more platforms.

[courbet]

Summary

• Target-independent tests are run all the time.
• Tests that codegen X86 code are run when X86 is in build targets.
• Tests that run X86 jitted code are run only on X86 hosts.

[courbet]

cleanup

unittests/tools/CMakeLists.txt

 if(LLVM_TARGETS_TO_BUILD MATCHES "X86")
   add_subdirectory(
     llvm-cfi-verify
   )
-  if(LLVM_HOST_TRIPLE MATCHES "x86_64")
-    add_subdirectory(
-      llvm-exegesis
-    )
-  endif()
-endif()
+endif()
+
 

unittests/tools/llvm-exegesis/CMakeLists.txt

 include_directories(
-  ${LLVM_MAIN_SRC_DIR}/lib/Target/X86
-  ${LLVM_BINARY_DIR}/lib/Target/X86
   ${LLVM_MAIN_SRC_DIR}/tools/llvm-exegesis/lib
   )
 
 set(LLVM_LINK_COMPONENTS
   MC
   MCParser
   Object
   Support
   Symbolize
-  native
   )
 
 add_llvm_unittest(LLVMExegesisTests
   BenchmarkResultTest.cpp
-  InMemoryAssemblerTest.cpp
-  InstructionSnippetGeneratorTest.cpp
   OperandGraphTest.cpp
   PerfHelperTest.cpp
   )
 target_link_libraries(LLVMExegesisTests PRIVATE LLVMExegesis)
 
 if(LLVM_ENABLE_LIBPFM AND HAVE_LIBPFM)
   target_link_libraries(LLVMExegesisTests PRIVATE pfm)
 endif()
+
+if(LLVM_TARGETS_TO_BUILD MATCHES "X86")
+  add_subdirectory(
+    X86
+  )
+endif()

unittests/tools/llvm-exegesis/X86/CMakeLists.txt

 include_directories(
   ${LLVM_MAIN_SRC_DIR}/lib/Target/X86
   ${LLVM_BINARY_DIR}/lib/Target/X86
   ${LLVM_MAIN_SRC_DIR}/tools/llvm-exegesis/lib
   )
 
 set(LLVM_LINK_COMPONENTS
   MC
   MCParser
   Object
   Support
   Symbolize
-  native
+  X86
   )
 
-add_llvm_unittest(LLVMExegesisTests
-  BenchmarkResultTest.cpp
+add_llvm_unittest(LLVMExegesisX86Tests
   InMemoryAssemblerTest.cpp
   InstructionSnippetGeneratorTest.cpp
-  OperandGraphTest.cpp
-  PerfHelperTest.cpp
   )
-target_link_libraries(LLVMExegesisTests PRIVATE LLVMExegesis)
+target_link_libraries(LLVMExegesisX86Tests PRIVATE LLVMExegesis)
 
-if(LLVM_ENABLE_LIBPFM AND HAVE_LIBPFM)
-  target_link_libraries(LLVMExegesisTests PRIVATE pfm)
-endif()

unittests/tools/llvm-exegesis/X86/InMemoryAssemblerTest.cpp

 
 class MachineFunctionGeneratorTest : public ::testing::Test {
 protected:
   MachineFunctionGeneratorTest()
       : TT(llvm::sys::getProcessTriple()),
         CpuName(llvm::sys::getHostCPUName().str()) {}
 
   static void SetUpTestCase() {
-    llvm::InitializeNativeTarget();
-    llvm::InitializeNativeTargetAsmPrinter();
+    LLVMInitializeX86TargetInfo();
+    LLVMInitializeX86TargetMC();
+    LLVMInitializeX86Target();
+    LLVMInitializeX86AsmPrinter();
   }
 
   std::unique_ptr<llvm::LLVMTargetMachine> createTargetMachine() {
     std::string Error;
     const llvm::Target *TheTarget =
         llvm::TargetRegistry::lookupTarget(TT, Error);
     assert(TheTarget);
     const llvm::TargetOptions Options;
     return std::unique_ptr<llvm::LLVMTargetMachine>(
         static_cast<llvm::LLVMTargetMachine *>(TheTarget->createTargetMachine(
             TT, CpuName, "", Options, llvm::Reloc::Model::Static)));
   }
 
+  bool IsSupportedTarget() const {
+    return llvm::StringRef(TT).startswith_lower("x86_64");
+  }
+
 private:
   const std::string TT;
   const std::string CpuName;
 };
 
-TEST_F(MachineFunctionGeneratorTest, DISABLED_JitFunction) {
+// Used to skip tests on unsupported architectures and operating systems.
+// To skip a test, add this macro at the top of a test-case.
+#define SKIP_UNSUPPORTED_PLATFORM \
+  do \
+    if (!IsSupportedTarget()) \
+      return; \
+  while(0)
+
+
+TEST_F(MachineFunctionGeneratorTest, JitFunction) {
+  SKIP_UNSUPPORTED_PLATFORM;
   JitFunctionContext Context(createTargetMachine());
   JitFunction Function(std::move(Context), {});
   ASSERT_THAT(Function.getFunctionBytes().str(), ElementsAre(0xc3));
   // FIXME: Check that the function runs without errors. Right now this is
   // disabled because it fails on some bots.
   // Function();
 }
 
-TEST_F(MachineFunctionGeneratorTest, DISABLED_JitFunctionXOR32rr) {
+TEST_F(MachineFunctionGeneratorTest, JitFunctionXOR32rr) {
+  SKIP_UNSUPPORTED_PLATFORM;
   JitFunctionContext Context(createTargetMachine());
   JitFunction Function(
       std::move(Context),
       {MCInstBuilder(XOR32rr).addReg(EAX).addReg(EAX).addReg(EAX)});
   ASSERT_THAT(Function.getFunctionBytes().str(), ElementsAre(0x31, 0xc0, 0xc3));
   // Function();
 }
 
-TEST_F(MachineFunctionGeneratorTest, DISABLED_JitFunctionMOV64ri) {
+TEST_F(MachineFunctionGeneratorTest, JitFunctionMOV64ri) {
+  SKIP_UNSUPPORTED_PLATFORM;
   JitFunctionContext Context(createTargetMachine());
   JitFunction Function(std::move(Context),
                        {MCInstBuilder(MOV64ri32).addReg(RAX).addImm(42)});
   ASSERT_THAT(Function.getFunctionBytes().str(),
               ElementsAre(0x48, 0xc7, 0xc0, 0x2a, 0x00, 0x00, 0x00, 0xc3));
   // Function();
 }
 
-TEST_F(MachineFunctionGeneratorTest, DISABLED_JitFunctionMOV32ri) {
+TEST_F(MachineFunctionGeneratorTest, JitFunctionMOV32ri) {
+  SKIP_UNSUPPORTED_PLATFORM;
   JitFunctionContext Context(createTargetMachine());
   JitFunction Function(std::move(Context),
                        {MCInstBuilder(MOV32ri).addReg(EAX).addImm(42)});
   ASSERT_THAT(Function.getFunctionBytes().str(),
               ElementsAre(0xb8, 0x2a, 0x00, 0x00, 0x00, 0xc3));
   // Function();
 }
 
 } // namespace
 } // namespace exegesis

unittests/tools/llvm-exegesis/X86/InstructionSnippetGeneratorTest.cpp

 using llvm::X86::AL;
 using llvm::X86::AX;
 using llvm::X86::EFLAGS;
 using llvm::X86::RAX;
 
 class MCInstrDescViewTest : public ::testing::Test {
 protected:
   MCInstrDescViewTest()
-      : TheTriple(llvm::sys::getProcessTriple()),
-        CpuName(llvm::sys::getHostCPUName().str()) {}
+      : TheTriple("x86_64") {}
 
-  void SetUp() override {
-    llvm::InitializeNativeTarget();
+  static void SetUpTestCase() {
+    LLVMInitializeX86TargetInfo();
+    LLVMInitializeX86TargetMC();
+    LLVMInitializeX86Target();
+  }
 
+  void SetUp() override {
     std::string Error;
     const auto *Target = llvm::TargetRegistry::lookupTarget(TheTriple, Error);
     InstrInfo.reset(Target->createMCInstrInfo());
     RegInfo.reset(Target->createMCRegInfo(TheTriple));
   }
 
   const std::string TheTriple;
-  const std::string CpuName;
   std::unique_ptr<const llvm::MCInstrInfo> InstrInfo;
   std::unique_ptr<const llvm::MCRegisterInfo> RegInfo;
 };
 
 MATCHER(IsDef, "") { return arg.IsDef; }
 MATCHER(IsUse, "") { return arg.IsUse; }
 MATCHER_P2(EqVarAssignement, VariableIndexMatcher, AssignedRegisterMatcher,
            "") {