[llvm-exegesis] A mechanism to add target-specific functionality.

[courbet]

Summary

This is a step towards implementing memory operands and X87.

[courbet]

Add missing file.

[gchatelet]

tools/llvm-exegesis/lib/Target.cpp

31

"Target has already been registered"

tools/llvm-exegesis/lib/Uops.cpp

87

Is the code to generate the memory Operands in?

tools/llvm-exegesis/llvm-exegesis.cpp

127

You shouldn't need the guard.

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

22

EXPECT_THAT(..., NotNull()) ?

[courbet]

address review comments

tools/llvm-exegesis/lib/Uops.cpp

87

Thanks for the catch, I did not want to submit this.

tools/llvm-exegesis/llvm-exegesis.cpp

127

It's needed in case the target is not supported or not built for.

[courbet]

rebase

tools/llvm-exegesis/CMakeLists.txt

+
 set(LLVM_LINK_COMPONENTS
   Support
   native
   )
 
 add_llvm_tool(llvm-exegesis
   llvm-exegesis.cpp
   )
 
 add_subdirectory(lib)
-target_link_libraries(llvm-exegesis PRIVATE LLVMExegesis)
+
+# Link the native exegesis target if compiled and on the right host.
+if ((LLVM_TARGETS_TO_BUILD MATCHES "X86") AND ("${LLVM_NATIVE_ARCH}" STREQUAL "X86"))
+  set(LLVM_NATIVE_ARCH "X86")
+endif()
+
+if (LLVM_NATIVE_ARCH)
+  set(LLVM_EXEGESIS_NATIVE_TARGET "LLVMExegesis${LLVM_NATIVE_ARCH}")
+  set_source_files_properties(llvm-exegesis.cpp PROPERTIES COMPILE_FLAGS "-DLLVM_EXEGESIS_INITIALIZE_NATIVE_TARGET=Initialize${LLVM_NATIVE_ARCH}ExegesisTarget")
+endif()
+
+target_link_libraries(llvm-exegesis PRIVATE
+  LLVMExegesis
+  ${LLVM_EXEGESIS_NATIVE_TARGET}
+  )

tools/llvm-exegesis/lib/CMakeLists.txt

+if (LLVM_TARGETS_TO_BUILD MATCHES "X86")
+  add_subdirectory(X86)
+endif()
+
 add_library(LLVMExegesis
   STATIC
   Analysis.cpp
   Assembler.cpp
   BenchmarkResult.cpp
   BenchmarkRunner.cpp
   Clustering.cpp
   Latency.cpp
   LlvmState.cpp
   MCInstrDescView.cpp
   PerfHelper.cpp
   RegisterAliasing.cpp
+  Target.cpp
   Uops.cpp
   X86.cpp
   )
 
 llvm_update_compile_flags(LLVMExegesis)
 llvm_map_components_to_libnames(libs
   Analysis
   CodeGen

tools/llvm-exegesis/lib/Target.h

+//===-- Target.h ------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+///
+/// Classes that handle the creation of target-specific objects. This is
+/// similar to llvm::Target/TargetRegistry.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_LLVM_EXEGESIS_TARGET_H
+#define LLVM_TOOLS_LLVM_EXEGESIS_TARGET_H
+
+#include "llvm/ADT/Triple.h"
+
+namespace exegesis {
+
+class ExegesisTarget {
+public:
+  // Returns the ExegesisTarget for the given triple or nullptr if the target
+  // does not exist.
+  static const ExegesisTarget* lookup(llvm::StringRef TT);
+  // Registers a target. Not thread safe.
+  static void registerTarget(ExegesisTarget *T);
+
+  ~ExegesisTarget();
+
+private:
+  virtual bool matchesArch(llvm::Triple::ArchType Arch) const = 0;
+  const ExegesisTarget* Next = nullptr;
+};
+
+}  // namespace exegesis
+
+#endif // LLVM_TOOLS_LLVM_EXEGESIS_TARGET_H

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();
+  for (const ExegesisTarget* T = FirstTarget; T != nullptr; T = T->Next) {
+    if (T->matchesArch(Arch)) 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

tools/llvm-exegesis/lib/Uops.cpp

 // best.
 
 namespace exegesis {
 
 static bool hasUnknownOperand(const llvm::MCOperandInfo &OpInfo) {
   return OpInfo.OperandType == llvm::MCOI::OPERAND_UNKNOWN;
 }
 
 // FIXME: Handle memory, see PR36905.
 static bool hasMemoryOperand(const llvm::MCOperandInfo &OpInfo) {
   return OpInfo.OperandType == llvm::MCOI::OPERAND_MEMORY;
 }
 
 llvm::Error
 UopsBenchmarkRunner::isInfeasible(const llvm::MCInstrDesc &MCInstrDesc) const {
   if (MCInstrDesc.isPseudo())
     return llvm::make_error<BenchmarkFailure>("Infeasible : is pseudo");
   if (llvm::any_of(MCInstrDesc.operands(), hasUnknownOperand))
     return llvm::make_error<BenchmarkFailure>(
         "Infeasible : has unknown operands");
   if (llvm::any_of(MCInstrDesc.operands(), hasMemoryOperand))
-    return llvm::make_error<BenchmarkFailure>(
-        "Infeasible : has memory operands");
+    return llvm::make_error<BenchmarkFailure>("Infeasible : has memory operands");
   return llvm::Error::success();
 }
 
 // Returns whether this Variable ties Use and Def operands together.
 static bool hasTiedOperands(const Variable &Var) {
   bool HasUse = false;
   bool HasDef = false;
   for (const Operand *Op : Var.TiedOperands) {

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

+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")

tools/llvm-exegesis/lib/X86/LLVMBuild.txt

+;===- ./tools/llvm-exegesis/lib/X86LLVMBuild.txt ---------------*- Conf -*--===;
+;
+;                     The LLVM Compiler Infrastructure
+;
+; This file is distributed under the University of Illinois Open Source
+; License. See LICENSE.TXT for details.
+;
+;===------------------------------------------------------------------------===;
+;
+; This is an LLVMBuild description file for the components in this subdirectory.
+;
+; For more information on the LLVMBuild system, please see:
+;
+;   http://llvm.org/docs/LLVMBuild.html
+;
+;===------------------------------------------------------------------------===;
+
+[component_0]
+type = Library
+name = ExegesisX86
+parent = Libraries
+required_libraries = X86

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"
+
+namespace exegesis {
+
+namespace {
+
+class ExegesisX86Target : public ExegesisTarget {
+private:
+  bool matchesArch(llvm::Triple::ArchType Arch) const override {
+    return Arch == llvm::Triple::x86_64 || Arch == llvm::Triple::x86;
+  }
+};
+
+} // namespace
+
+static ExegesisTarget* getTheExegesisX86Target() {
+  static ExegesisX86Target Target;
+  return &Target;
+}
+
+void InitializeX86ExegesisTarget() {
+  ExegesisTarget::registerTarget(getTheExegesisX86Target());
+}
+
+}  // namespace exegesis

tools/llvm-exegesis/llvm-exegesis.cpp

 static llvm::cl::opt<std::string>
     AnalysisInconsistenciesOutputFile("analysis-inconsistencies-output-file",
                                       llvm::cl::desc(""), llvm::cl::init("-"));
 
 namespace exegesis {
 
 static llvm::ExitOnError ExitOnErr;
 
+#ifdef LLVM_EXEGESIS_INITIALIZE_NATIVE_TARGET
+void LLVM_EXEGESIS_INITIALIZE_NATIVE_TARGET();
+#endif
+
 static unsigned GetOpcodeOrDie(const llvm::MCInstrInfo &MCInstrInfo) {
   if (OpcodeName.empty() && (OpcodeIndex == 0))
     llvm::report_fatal_error(
         "please provide one and only one of 'opcode-index' or 'opcode-name'");
   if (OpcodeIndex > 0)
     return OpcodeIndex;
   // Resolve opcode name -> opcode.
   for (unsigned I = 0, E = MCInstrInfo.getNumOpcodes(); I < E; ++I)

 }
 
 void benchmarkMain() {
   if (exegesis::pfm::pfmInitialize())
     llvm::report_fatal_error("cannot initialize libpfm");
 
   llvm::InitializeNativeTarget();
   llvm::InitializeNativeTargetAsmPrinter();
+#ifdef LLVM_EXEGESIS_INITIALIZE_NATIVE_TARGET
+  LLVM_EXEGESIS_INITIALIZE_NATIVE_TARGET();
+#endif
 
   // FIXME: Target-specific filter.
   X86Filter Filter;
 
   const LLVMState State;
   const auto Opcode = GetOpcodeOrDie(State.getInstrInfo());
 
   // Ignore instructions without a sched class if -ignore-invalid-sched-class is

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

set(LLVM_LINK_COMPONENTS
   X86
   )
 
 add_llvm_unittest(LLVMExegesisX86Tests
   AssemblerTest.cpp
   AnalysisTest.cpp
   SnippetGeneratorTest.cpp
   RegisterAliasingTest.cpp
+  TargetTest.cpp
   )
-target_link_libraries(LLVMExegesisX86Tests PRIVATE LLVMExegesis)
+target_link_libraries(LLVMExegesisX86Tests PRIVATE
+  LLVMExegesis
+  LLVMExegesisX86)

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

+#include "Target.h"
+
+#include <cassert>
+#include <memory>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace exegesis {
+
+void InitializeX86ExegesisTarget();
+
+namespace {
+
+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());
+}
+
+} // namespace
+} // namespace exegesis