[llvm-exegesis] Add mechanism to add target-specific passes.

[courbet]

Summary

createX86FloatingPointStackifierPass is disabled until we handle
TracksLiveness correctly.

[courbet]

clang-format

llvm/trunk/tools/llvm-exegesis/lib/Assembler.cpp

 //===-- Assembler.cpp -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Assembler.h"
 
+#include "Target.h"
 #include "llvm/CodeGen/GlobalISel/CallLowering.h"
 #include "llvm/CodeGen/GlobalISel/MachineIRBuilder.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/TargetInstrInfo.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
void assembleToStream(std::unique_ptr<llvm::LLVMTargetMachine> TM,
   llvm::MachineFunction &MF =
       createVoidVoidMachineFunction(FunctionID, Module.get(), MMI.get());
 
   // We need to instruct the passes that we're done with SSA and virtual
   // registers.
   auto &Properties = MF.getProperties();
   Properties.set(llvm::MachineFunctionProperties::Property::NoVRegs);
   Properties.reset(llvm::MachineFunctionProperties::Property::IsSSA);
+  // FIXME: Remove this when we assign all used registers as config step. This
+  // essentially disables checks that used registers are def'ed somewhere.
   Properties.reset(llvm::MachineFunctionProperties::Property::TracksLiveness);
   // prologue/epilogue pass needs the reserved registers to be frozen, this
   // is usually done by the SelectionDAGISel pass.
   MF.getRegInfo().freezeReservedRegs(MF);
 
   // Fill the MachineFunction from the instructions.
   fillMachineFunction(MF, Instructions);
 
   // We create the pass manager, run the passes to populate AsmBuffer.
   llvm::MCContext &MCContext = MMI->getContext();
   llvm::legacy::PassManager PM;
 
   llvm::TargetLibraryInfoImpl TLII(llvm::Triple(Module->getTargetTriple()));
   PM.add(new llvm::TargetLibraryInfoWrapperPass(TLII));
 
   llvm::TargetPassConfig *TPC = TM->createPassConfig(PM);
   PM.add(TPC);
   PM.add(MMI.release());
   TPC->printAndVerify("MachineFunctionGenerator::assemble");
+  // Add target-specific passes.
+  if (const auto *ET = ExegesisTarget::lookup(TM->getTargetTriple())) {
+    ET->addTargetSpecificPasses(PM);
+    TPC->printAndVerify("After ExegesisTarget::addTargetSpecificPasses");
+  }
   // Adding the following passes:
   // - machineverifier: checks that the MachineFunction is well formed.
   // - prologepilog: saves and restore callee saved registers.
   for (const char *PassName : {"machineverifier", "prologepilog"})
     if (addPass(PM, PassName, *TPC))
       llvm::report_fatal_error("Unable to add a mandatory pass");
   TPC->setInitialized();
 

llvm/trunk/tools/llvm-exegesis/lib/Target.h

 /// similar to llvm::Target/TargetRegistry.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_EXEGESIS_TARGET_H
 #define LLVM_TOOLS_LLVM_EXEGESIS_TARGET_H
 
 #include "llvm/ADT/Triple.h"
+#include "llvm/CodeGen/TargetPassConfig.h"
+#include "llvm/IR/LegacyPassManager.h"
 
 namespace exegesis {
 
 class ExegesisTarget {
 public:
+  // Targets can use this to add target-specific passes in assembleToStream();
+  virtual void addTargetSpecificPasses(llvm::PassManagerBase &PM) const {}
+
   // Returns the ExegesisTarget for the given triple or nullptr if the target
   // does not exist.
-  static const ExegesisTarget* lookup(llvm::StringRef TT);
+  static const ExegesisTarget *lookup(llvm::Triple TT);
   // Registers a target. Not thread safe.
   static void registerTarget(ExegesisTarget *T);
 
   virtual ~ExegesisTarget();
 
 private:
   virtual bool matchesArch(llvm::Triple::ArchType Arch) const = 0;
   const ExegesisTarget* Next = nullptr;
 };
 
 }  // namespace exegesis
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_TARGET_H

llvm/trunk/tools/llvm-exegesis/lib/Target.cpp

 //===-- Target.cpp ----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #include "Target.h"
 
 namespace exegesis {
 
 ExegesisTarget::~ExegesisTarget() {}  // anchor.
 
 static ExegesisTarget* FirstTarget = nullptr;
 
-const ExegesisTarget* ExegesisTarget::lookup(llvm::StringRef TT) {
-  const llvm::Triple::ArchType Arch = llvm::Triple(TT).getArch();
+const ExegesisTarget *ExegesisTarget::lookup(llvm::Triple TT) {
   for (const ExegesisTarget* T = FirstTarget; T != nullptr; T = T->Next) {
-    if (T->matchesArch(Arch)) return T;
+    if (T->matchesArch(TT.getArch()))
+      return T;
   }
   return nullptr;
 }
 
 void ExegesisTarget::registerTarget(ExegesisTarget *Target){
   if (FirstTarget == nullptr) {
     FirstTarget = Target;
     return;
   }
   assert(Target->Next == nullptr && "target has already been registered");
   if (Target->Next != nullptr)
     return;
   Target->Next = FirstTarget;
   FirstTarget = Target;
 }
 }  // namespace exegesis

llvm/trunk/tools/llvm-exegesis/lib/X86/CMakeLists.txt

+include_directories(
+  ${LLVM_MAIN_SRC_DIR}/lib/Target/X86
+  ${LLVM_BINARY_DIR}/lib/Target/X86
+  )
+
 add_library(LLVMExegesisX86
   STATIC
   Target.cpp
   )
 
 llvm_update_compile_flags(LLVMExegesisX86)
 llvm_map_components_to_libnames(libs
   X86
   Exegesis
   )
 
 target_link_libraries(LLVMExegesisX86 ${libs})
 set_target_properties(LLVMExegesisX86 PROPERTIES FOLDER "Libraries")

llvm/trunk/tools/llvm-exegesis/lib/X86/Target.cpp

 //===-- Target.cpp ----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #include "../Target.h"
 
+#include "X86.h"
+
 namespace exegesis {
 
 namespace {
 
 class ExegesisX86Target : public ExegesisTarget {
-private:
+  void addTargetSpecificPasses(llvm::PassManagerBase &PM) const override {
+    // Lowers FP pseudo-instructions, e.g. ABS_Fp32 -> ABS_F.
+    // FIXME: Enable when the exegesis assembler no longer does
+    // Properties.reset(TracksLiveness);
+    // PM.add(llvm::createX86FloatingPointStackifierPass());
+  }
+
   bool matchesArch(llvm::Triple::ArchType Arch) const override {
     return Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::x86;
   }
 };
 
 } // namespace
 
 static ExegesisTarget* getTheExegesisX86Target() {

llvm/trunk/unittests/tools/llvm-exegesis/X86/TargetTest.cpp

 using testing::NotNull;
 
 class X86TargetTest : public ::testing::Test {
 protected:
   static void SetUpTestCase() { InitializeX86ExegesisTarget(); }
 };
 
 TEST_F(X86TargetTest, Lookup) {
-  EXPECT_THAT(ExegesisTarget::lookup("x86_64-unknown-linux"), NotNull());
+  EXPECT_THAT(ExegesisTarget::lookup(llvm::Triple("x86_64-unknown-linux")),
+              NotNull());
 }
 
 } // namespace
 } // namespace exegesis