[llvm-exegesis] Initialize all supported targets

[reames]

Summary

Enable registration of multiple exegesis targets at once. Use idiomatic approach to defining target select macros, but leave code in the llvm-mca sub-directories for now.

This is a stepping stone towards allowing llvm-exegesis benchmarking via simulator or testing in non-target dependent tests.

Note: I have not been able to test the analysis mode. I can't get the build system to recognize the pfm library on my build machine. As such, please double check me that the registration code which already existed appears to handle multiple registered targets correctly.

[reames]

I think I got something wrong here. Seeing something odd when building on top of this, marking as plan changes until I figure it out.

[reames]

Fix a typo in cmake which resulted in no targets being listed in TargetExegesis.def and thus no targets actually registered.

[courbet]

As such, please double check me that the registration code which already existed appears to handle multiple registered targets correctly.

It doesn't actually (yaml parsing code needs to know the target beforehand because it parses instruction names to target-specific opcodes). I'll send a patch.

[courbet]

llvm/tools/llvm-exegesis/llvm-exegesis.cpp

443

Once D133697 is in you can add InitializeAllExegesisTargets(); here.

[reames]

In D133605#3783279, @courbet wrote:

As such, please double check me that the registration code which already existed appears to handle multiple registered targets correctly.

It doesn't actually (yaml parsing code needs to know the target beforehand because it parses instruction names to target-specific opcodes). I'll send a patch.

Thanks.

[reames]

@courbet Anything blocking this now that your change has landed?

llvm/CMakeLists.txt

 
 # Configure all of the various header file fragments LLVM uses which depend on
 # configuration variables.
 set(LLVM_ENUM_TARGETS "")
 set(LLVM_ENUM_ASM_PRINTERS "")
 set(LLVM_ENUM_ASM_PARSERS "")
 set(LLVM_ENUM_DISASSEMBLERS "")
 set(LLVM_ENUM_TARGETMCAS "")
+set(LLVM_ENUM_EXEGESIS "")
 foreach(t ${LLVM_TARGETS_TO_BUILD})
   set( td ${LLVM_MAIN_SRC_DIR}/lib/Target/${t} )
 
   list(FIND LLVM_ALL_TARGETS ${t} idx)
   list(FIND LLVM_EXPERIMENTAL_TARGETS_TO_BUILD ${t} idy)
   # At this point, LLVMBUILDTOOL already checked all the targets passed in
   # LLVM_TARGETS_TO_BUILD and LLVM_EXPERIMENTAL_TARGETS_TO_BUILD, so
   # this test just makes sure that any experimental targets were passed via
foreach(t ${LLVM_TARGETS_TO_BUILD})
   if( EXISTS ${td}/AsmParser/CMakeLists.txt )
     set(LLVM_ENUM_ASM_PARSERS
       "${LLVM_ENUM_ASM_PARSERS}LLVM_ASM_PARSER(${t})\n")
   endif()
   if( EXISTS ${td}/Disassembler/CMakeLists.txt )
     set(LLVM_ENUM_DISASSEMBLERS
       "${LLVM_ENUM_DISASSEMBLERS}LLVM_DISASSEMBLER(${t})\n")
   endif()
-    if( EXISTS ${td}/MCA/CMakeLists.txt )
     set(LLVM_ENUM_TARGETMCAS
       "${LLVM_ENUM_TARGETMCAS}LLVM_TARGETMCA(${t})\n")
   endif()
+  if( EXISTS ${LLVM_MAIN_SRC_DIR}/tools/llvm-exegesis/lib/${t}/CMakeLists.txt )
+    set(LLVM_ENUM_EXEGESIS
+      "${LLVM_ENUM_EXEGESIS}LLVM_EXEGESIS(${t})\n")
+  endif()
 endforeach(t)
 
 # Provide an LLVM_ namespaced alias for use in #cmakedefine.
 set(LLVM_BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS})
 
 # Produce the target definition files, which provide a way for clients to easily
 # include various classes of targets.
 configure_file(

 configure_file(
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Config/Targets.def.in
   ${LLVM_INCLUDE_DIR}/llvm/Config/Targets.def
   )
 configure_file(
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Config/TargetMCAs.def.in
   ${LLVM_INCLUDE_DIR}/llvm/Config/TargetMCAs.def
   )
+configure_file(
+  ${LLVM_MAIN_INCLUDE_DIR}/llvm/Config/TargetExegesis.def.in
+  ${LLVM_INCLUDE_DIR}/llvm/Config/TargetExegesis.def
+  )
 
 # They are not referenced. See set_output_directory().
 set( CMAKE_RUNTIME_OUTPUT_DIRECTORY ${LLVM_TOOLS_BINARY_DIR} )
 set( CMAKE_LIBRARY_OUTPUT_DIRECTORY ${LLVM_LIBRARY_DIR} )
 set( CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${LLVM_LIBRARY_DIR} )
 
 if(LLVM_INCLUDE_TESTS)
   include(GetErrcMessages)

llvm/include/llvm/Config/TargetExegesis.def.in

+/*===----- llvm/Config/TargetExegesis.def - LLVM Target Exegesis-*- C++ -*-===*\
+|*                                                                            *|
+|* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
+|* Exceptions.                                                                *|
+|* See https://llvm.org/LICENSE.txt for license information.                  *|
+|* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
+|*                                                                            *|
+|*===----------------------------------------------------------------------===*|
+|*                                                                            *|
+|* This file enumerates all of the target's of llvm-exegesis                  *|
+|* supported by this build of LLVM. Clients of this file should define        *|
+|* the LLVM_EXEGISIS macro to be a function-like macro with a                 *|
+|* single parameter (the name of the target whose assembly can be             *|
+|* generated); including this file will then enumerate all of the             *|
+|* targets with target llvm-exegsis support.                                  *|
+|*                                                                            *|
+|* The set of targets supported by LLVM is generated at configuration         *|
+|* time, at which point this header is generated. Do not modify this          *|
+|* header directly.                                                           *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+#ifndef LLVM_EXEGESIS
+#  error Please define the macro LLVM_EXEGESIS(TargetName)
+#endif
+
+@LLVM_ENUM_EXEGESIS@
+
+#undef LLVM_EXEGESIS

llvm/tools/llvm-exegesis/CMakeLists.txt

add_llvm_tool(llvm-exegesis
 
   DEPENDS
   intrinsics_gen
   )
 
 # Has side effect of defining LLVM_EXEGESIS_TARGETS
 add_subdirectory(lib)
 
-# Register the native target (we don't yet support -march)
-if (LLVM_EXEGESIS_TARGETS MATCHES "${LLVM_NATIVE_ARCH}")
-  set(LLVM_EXEGESIS_NATIVE_ARCH "${LLVM_NATIVE_ARCH}")
-  set_source_files_properties(llvm-exegesis.cpp PROPERTIES COMPILE_FLAGS "-DLLVM_EXEGESIS_INITIALIZE_NATIVE_TARGET=Initialize${LLVM_EXEGESIS_NATIVE_ARCH}ExegesisTarget")
-endif()
-
-# Link the native exegesis targets
+# Link all enabled exegesis targets
 set(libs)
 foreach(t ${LLVM_EXEGESIS_TARGETS})
   string(STRIP ${t} t)
   list(APPEND libs "LLVMExegesis${t}")
 endforeach()
 
 target_link_libraries(llvm-exegesis PRIVATE
   LLVMExegesis
   ${libs}
   )

llvm/tools/llvm-exegesis/lib/TargetSelect.h

 //===-- TargetSelect.h ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 ///
-/// Utilities to handle the creation of the native exegesis target.
+/// Utilities to handle the creation of the enabled exegesis target(s).
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_EXEGESIS_TARGET_SELECT_H
 #define LLVM_TOOLS_LLVM_EXEGESIS_TARGET_SELECT_H
 
+#include "llvm/Config/llvm-config.h"
+
 namespace llvm {
 namespace exegesis {
 
-#ifdef LLVM_EXEGESIS_INITIALIZE_NATIVE_TARGET
-void LLVM_EXEGESIS_INITIALIZE_NATIVE_TARGET();
-#endif
-
-// Initializes the native exegesis target, or returns false if there is no
-// native target (either because llvm-exegesis does not support the target or
-// because it's not linked in).
-inline bool InitializeNativeExegesisTarget() {
-#ifdef LLVM_EXEGESIS_INITIALIZE_NATIVE_TARGET
-  LLVM_EXEGESIS_INITIALIZE_NATIVE_TARGET();
-  return true;
-#else
-  return false;
-#endif
+// Forward declare all of the initialize methods for targets compiled in
+#define LLVM_EXEGESIS(TargetName) void Initialize##TargetName##ExegesisTarget();
+#include "llvm/Config/TargetExegesis.def"
+
+// Initializes all exegesis targets compiled in.
+inline void InitializeAllExegesisTargets() {
+#define LLVM_EXEGESIS(TargetName) Initialize##TargetName##ExegesisTarget();
+#include "llvm/Config/TargetExegesis.def"
 }
 
 } // namespace exegesis
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_TARGET_SELECT_H

llvm/tools/llvm-exegesis/llvm-exegesis.cpp

#endif
 
   if (exegesis::pfm::pfmInitialize())
     ExitWithError("cannot initialize libpfm");
 
   InitializeAllTargets();
   InitializeAllTargetMCs();
   InitializeAllAsmPrinters();
   InitializeAllAsmParsers();
-  InitializeNativeExegesisTarget();
+  InitializeAllExegesisTargets();
 
   const LLVMState State = ExitOnErr(LLVMState::Create("", CpuName));
 
   // Preliminary check to ensure features needed for requested
   // benchmark mode are present on target CPU and/or OS.
   ExitOnErr(State.getExegesisTarget().checkFeatureSupport());
 
   const std::unique_ptr<BenchmarkRunner> Runner =
static void analysisMain() {
 
   if (AnalysisClustersOutputFile.empty() &&
       AnalysisInconsistenciesOutputFile.empty()) {
     ExitWithError(
         "for --mode=analysis: At least one of --analysis-clusters-output-file "
         "and --analysis-inconsistencies-output-file must be specified");
   }
 
-  InitializeNativeTarget();
-  InitializeNativeTargetAsmPrinter();
-  InitializeNativeTargetDisassembler();
-  InitializeNativeExegesisTarget();
+  InitializeAllTargets();
+  InitializeAllTargetMCs();
+  InitializeAllAsmPrinters();
+  InitializeAllDisassemblers();
+  InitializeAllExegesisTargets();
 
   auto MemoryBuffer = ExitOnFileError(
       BenchmarkFile,
       errorOrToExpected(MemoryBuffer::getFile(BenchmarkFile, /*IsText=*/true)));
 
   const auto TriplesAndCpus = ExitOnFileError(
       BenchmarkFile,
       InstructionBenchmark::readTriplesAndCpusFromYamls(*MemoryBuffer));
   if (TriplesAndCpus.empty()) {
     errs() << "no benchmarks to analyze\n";
     return;
   }
   if (TriplesAndCpus.size() > 1) {
     ExitWithError("analysis file contains benchmarks from several CPUs. This "
                   "is unsupported.");
   }
   auto TripleAndCpu = *TriplesAndCpus.begin();
   if (!CpuName.empty()) {
     llvm::errs() << "overridding file CPU name (" << TripleAndCpu.CpuName
                  << ") with provided CPU name (" << CpuName << ")\n";
     TripleAndCpu.CpuName = CpuName;
   }
   llvm::errs() << "using Triple '" << TripleAndCpu.LLVMTriple << "' and CPU '"
                << TripleAndCpu.CpuName << "'\n";
 
   // Read benchmarks.
   const LLVMState State = ExitOnErr(
       LLVMState::Create(TripleAndCpu.LLVMTriple, TripleAndCpu.CpuName));
   const std::vector<InstructionBenchmark> Points = ExitOnFileError(
       BenchmarkFile, InstructionBenchmark::readYamls(State, *MemoryBuffer));
 
   outs() << "Parsed " << Points.size() << " benchmark points\n";
   if (Points.empty()) {