Support lit-tests in CMTrans-passes for llvm-16

List of passes with enabled tests:
* CMImpParam
* CMLowerVLoadVStore
* GenXPacketize
* BTIAssignment
* ImportOCLBiF

Author: igorban-intel

IGC/VectorCompiler/include/vc/GenXOpts/CMImpParam.h

@@ -13,6 +13,12 @@ void initializeCMImpParamPass(PassRegistry &);
 }
 
 struct CMImpParamPass : public llvm::PassInfoMixin<CMImpParamPass> {
+  bool HasPayloadInMemory = false;
+  CMImpParamPass(bool HasPayloadInMemoryIn)
+      : HasPayloadInMemory{HasPayloadInMemoryIn} {};
+
+  CMImpParamPass();
+
   llvm::PreservedAnalyses run(llvm::Module &M, llvm::ModuleAnalysisManager &AM);
 };
 

IGC/VectorCompiler/include/vc/Support/BackendConfig.h

@@ -230,19 +230,20 @@ class GenXBackendData {
                             std::unique_ptr<MemoryBuffer> ModuleBuffer);
 };
 
-class GenXBackendConfig : public ImmutablePass {
-public:
-  static char ID;
-
-private:
+struct GenXBackendConfigResult {
+protected:
   GenXBackendOptions Options;
   GenXBackendData Data;
 
-public:
-  GenXBackendConfig();
-  explicit GenXBackendConfig(GenXBackendOptions &&OptionsIn,
-                             GenXBackendData &&DataIn);
+  GenXBackendConfigResult(GenXBackendOptions &&OptionsIn,
+                          GenXBackendData &&DataIn)
+      : Options(std::move(OptionsIn)), Data(std::move(DataIn)){};
+
+  GenXBackendConfigResult()
+      : Options{GenXBackendOptions::InitFromLLVMOpts{}},
+        Data{GenXBackendData::InitFromLLMVOpts{}} {};
 
+public:
   // Return whether regalloc results should be printed.
   bool enableRegAllocDump() const { return Options.DumpRegAlloc; }
 
@@ -396,6 +397,30 @@ class GenXBackendConfig : public ImmutablePass {
 
   vc::BinaryKind getBinaryFormat() const { return Options.Binary; }
 };
+
+class GenXBackendConfig : public ImmutablePass, public GenXBackendConfigResult {
+public:
+  static char ID;
+
+public:
+  GenXBackendConfig();
+  explicit GenXBackendConfig(GenXBackendOptions &&OptionsIn,
+                             GenXBackendData &&DataIn);
+
+  GenXBackendConfigResult &getResult() { return *this; };
+};
 } // namespace llvm
 
+#if LLVM_VERSION_MAJOR >= 16
+
+#include "llvm/IR/PassManager.h"
+
+struct GenXBackendConfigPass
+    : public llvm::AnalysisInfoMixin<GenXBackendConfigPass> {
+  using Result = llvm::GenXBackendConfigResult;
+  Result run(llvm::Module &M, llvm::ModuleAnalysisManager &AM);
+  static llvm::AnalysisKey Key;
+};
+#endif
+
 #endif

IGC/VectorCompiler/lib/GenXOpts/CMTrans/CMABI.cpp

@@ -1552,8 +1552,6 @@ llvm::PreservedAnalyses CMABIPass::run(llvm::Module &M,
                                        llvm::ModuleAnalysisManager &AM) {
 
   auto &LCG = AM.getResult<LazyCallGraphAnalysis>(M);
-  CGSCCAnalysisManager &CGAM =
-      AM.getResult<CGSCCAnalysisManagerModuleProxy>(M).getManager();
   LCG.buildRefSCCs();
   bool Changed = false;
   PreservedAnalyses PassPA;
@@ -1577,4 +1575,5 @@ PreservedAnalyses CMLowerVLoadVStorePass::run(Function &F,
   }
   return PreservedAnalyses::none();
 }
+
 #endif

IGC/VectorCompiler/lib/GenXOpts/CMTrans/CMImpParam.cpp

@@ -210,6 +210,18 @@ struct CMImpParam : public ModulePass {
   bool HasPayloadInMemory = false;
   const DataLayout *DL = nullptr;
 
+#if LLVM_VERSION_MAJOR >= 16
+  CallGraph &CG;
+  CMImpParam(CallGraph &CG, bool HasPayloadInMemoryIn)
+      : ModulePass{ID}, HasPayloadInMemory{HasPayloadInMemoryIn}, CG(CG) {
+    initializeCMImpParamPass(*PassRegistry::getPassRegistry());
+  }
+
+  CMImpParam(CallGraph &CG)
+      : ModulePass{ID}, HasPayloadInMemory{PayloadInMemoryOpt}, CG(CG) {
+    initializeCMImpParamPass(*PassRegistry::getPassRegistry());
+  }
+#else  // LLVM_VERSION_MAJOR
   CMImpParam(bool HasPayloadInMemoryIn)
       : ModulePass{ID}, HasPayloadInMemory{HasPayloadInMemoryIn} {
     initializeCMImpParamPass(*PassRegistry::getPassRegistry());
@@ -218,6 +230,7 @@ struct CMImpParam : public ModulePass {
   CMImpParam() : ModulePass{ID}, HasPayloadInMemory{PayloadInMemoryOpt} {
     initializeCMImpParamPass(*PassRegistry::getPassRegistry());
   }
+#endif // LLVM_VERSION_MAJOR
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<CallGraphWrapperPass>();
@@ -556,7 +569,9 @@ bool CMImpParam::runOnModule(Module &M) {
 void CMImpParam::processKernels(
     const std::vector<FunctionRef> &Kernels, const IntrIDMap &UsedIntrInfo,
     const std::unordered_set<Function *> &RequireImplArgsBuffer) {
+#if LLVM_VERSION_MAJOR < 16
   CallGraph &CG = getAnalysis<CallGraphWrapperPass>().getCallGraph();
+#endif
 
   for (Function &Kernel : Kernels) {
     // Traverse the call graph to determine what the total implicit uses are for
@@ -610,14 +625,16 @@ CMImpParam::analyzeFixedSignatureFunctions(Module &M,
                                            const IntrIDMap &UsedIntrInfo) {
   IntrIDMap FixedSignFuncInfo;
   std::unordered_set<Function *> RequireImplArgsBuffer;
+#if LLVM_VERSION_MAJOR < 16
   CallGraph &CG = getAnalysis<CallGraphWrapperPass>().getCallGraph();
-
+#endif
   auto FixedSignatureDefinitions = make_filter_range(
       M, [](const Function &F) { return vc::isFixedSignatureDefinition(F); });
 
   for (Function &F : FixedSignatureDefinitions) {
     auto [RequiredImplArgs, CalledFixedSignFuncs] =
         CallGraphTraverser{CG, UsedIntrInfo}.collectIndirectlyUsedImplArgs(F);
+
     // Function should be marked if it uses implicit args or it calls some
     // function that may use it via implicit args buffer.
     if (!RequiredImplArgs.empty() || !CalledFixedSignFuncs.has_value() ||
@@ -1013,6 +1030,9 @@ template <bool IsEntry> void CallGraphTraverser::visitFunction(Function &F) {
     // Skipping inline asm.
     if (isa<CallInst>(CI) && cast<CallInst>(CI)->isInlineAsm())
       continue;
+    if (!isa<CallInst>(CI) || (GenXIntrinsic::getAnyIntrinsicID(CI) !=
+                               GenXIntrinsic::not_any_intrinsic))
+      continue;
     // Returns nullptr in case of indirect call or inline asm which was already
     // considered.
     auto *Child = CallEdge.second->getFunction();
@@ -1160,7 +1180,9 @@ CMImpParam::processKernelParameters(Function *F,
     }
   }
 
+#if LLVM_VERSION_MAJOR < 16
   CallGraph &CG = getAnalysis<CallGraphWrapperPass>().getCallGraph();
+#endif
   CallGraphNode *NF_CGN = CG.getOrInsertFunction(NF);
 
   if (F->hasDLLExportStorageClass())
@@ -1206,20 +1228,22 @@ INITIALIZE_PASS_END(CMImpParam, "CMImpParam",
                     "Transformations required to support implicit arguments",
                     false, false)
 
+#if LLVM_VERSION_MAJOR < 16
 namespace llvm {
 Pass *createCMImpParamPass(bool HasPayloadInMemory) {
   return new CMImpParam{HasPayloadInMemory};
 }
 } // namespace llvm
 
-#if LLVM_VERSION_MAJOR >= 16
+#else // LLVM_VERSION_MAJOR < 16
 PreservedAnalyses CMImpParamPass::run(llvm::Module &M,
-                                      llvm::AnalysisManager<llvm::Module> &) {
-  CMImpParam cmip;
+                                      llvm::AnalysisManager<llvm::Module> &AM) {
+  auto &CG = AM.getResult<CallGraphAnalysis>(M);
+  CMImpParam cmip(CG);
   if (cmip.runOnModule(M)) {
     return PreservedAnalyses::all();
   }
   return PreservedAnalyses::none();
 }
-// TODO: No lit-tests
-#endif
+CMImpParamPass::CMImpParamPass() : HasPayloadInMemory{PayloadInMemoryOpt} {};
+#endif // LLVM_VERSION_MAJOR < 16

IGC/VectorCompiler/lib/GenXOpts/CMTrans/GenXBTIAssignment.cpp

@@ -89,10 +89,19 @@ class BTIAssignment final {
 
 class GenXBTIAssignment final : public ModulePass {
 
+#if LLVM_VERSION_MAJOR >= 16
+  GenXBackendConfigPass::Result &BC;
+#endif
+
 public:
   static char ID;
 
+#if LLVM_VERSION_MAJOR >= 16
+  GenXBTIAssignment(GenXBackendConfigPass::Result &BC)
+      : BC(BC), ModulePass(ID) {}
+#else  // LLVM_VERSION_MAJOR >= 16
   GenXBTIAssignment() : ModulePass(ID) {}
+#endif // LLVM_VERSION_MAJOR >= 16
 
   void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<GenXBackendConfig>();
@@ -112,18 +121,21 @@ INITIALIZE_PASS_DEPENDENCY(GenXBackendConfig)
 INITIALIZE_PASS_END(GenXBTIAssignment, "GenXBTIAssignment", "GenXBTIAssignment",
                     false, false);
 
+#if LLVM_VERSION_MAJOR < 16
 namespace llvm {
 ModulePass *createGenXBTIAssignmentPass() {
   initializeGenXBTIAssignmentPass(*PassRegistry::getPassRegistry());
   return new GenXBTIAssignment();
 }
 } // namespace llvm
+#endif
 
 #if LLVM_VERSION_MAJOR >= 16
 PreservedAnalyses
 GenXBTIAssignmentPass::run(llvm::Module &M,
-                           llvm::AnalysisManager<llvm::Module> &) {
-  GenXBTIAssignment GenXBTI;
+                           llvm::AnalysisManager<llvm::Module> &AM) {
+  auto &Res = AM.getResult<GenXBackendConfigPass>(M);
+  GenXBTIAssignment GenXBTI(Res);
   if (GenXBTI.runOnModule(M)) {
     return PreservedAnalyses::all();
   }
@@ -132,7 +144,9 @@ GenXBTIAssignmentPass::run(llvm::Module &M,
 #endif
 
 bool GenXBTIAssignment::runOnModule(Module &M) {
+#if LLVM_VERSION_MAJOR < 16
   auto &BC = getAnalysis<GenXBackendConfig>();
+#endif
   bool emitDebuggableKernels = BC.emitDebuggableKernelsForLegacyPath();
   bool useBindlessBuffers = BC.useBindlessBuffers();
   bool useBindlessImages = BC.useBindlessImages();

IGC/VectorCompiler/lib/GenXOpts/CMTrans/GenXTranslateSPIRVBuiltins.cpp

@@ -357,9 +357,18 @@ Value *SPIRVExpander::visitCallInst(CallInst &CI) {
 }
 
 class GenXTranslateSPIRVBuiltins final : public ModulePass {
+#if LLVM_VERSION_MAJOR >= 16
+  GenXBackendConfigPass::Result &BC;
+#endif
 public:
   static char ID;
+
+#if LLVM_VERSION_MAJOR >= 16
+  GenXTranslateSPIRVBuiltins(GenXBackendConfigPass::Result &BC)
+      : BC(BC), ModulePass(ID), Expander(nullptr) {}
+#else  // LLVM_VERSION_MAJOR >= 16
   GenXTranslateSPIRVBuiltins() : ModulePass(ID), Expander(nullptr) {}
+#endif // LLVM_VERSION_MAJOR >= 16
   StringRef getPassName() const override {
     return "GenX translate SPIR-V builtins";
   }
@@ -380,19 +389,22 @@ INITIALIZE_PASS_DEPENDENCY(GenXBackendConfig)
 INITIALIZE_PASS_END(GenXTranslateSPIRVBuiltins, "GenXTranslateSPIRVBuiltins",
                     "GenXTranslateSPIRVBuiltins", false, false)
 
+#if LLVM_VERSION_MAJOR < 16
 namespace llvm {
 ModulePass *createGenXTranslateSPIRVBuiltinsPass() {
   initializeGenXTranslateSPIRVBuiltinsPass(*PassRegistry::getPassRegistry());
   return new GenXTranslateSPIRVBuiltins;
 }
 } // namespace llvm
+#endif
 
 #if LLVM_VERSION_MAJOR >= 16
 PreservedAnalyses
 GenXTranslateSPIRVBuiltinsPass::run(llvm::Module &M,
-                                    llvm::AnalysisManager<llvm::Module> &) {
-  GenXTranslateSPIRVBuiltins GenXPrint;
-  if (GenXPrint.runOnModule(M)) {
+                                    llvm::AnalysisManager<llvm::Module> &AM) {
+  auto &Res = AM.getResult<GenXBackendConfigPass>(M);
+  GenXTranslateSPIRVBuiltins GenXTrans(Res);
+  if (GenXTrans.runOnModule(M)) {
     return PreservedAnalyses::all();
   }
   return PreservedAnalyses::none();
@@ -531,7 +543,11 @@ bool GenXTranslateSPIRVBuiltins::runOnFunction(Function &F) {
 
 std::unique_ptr<Module>
 GenXTranslateSPIRVBuiltins::getBiFModule(BiFKind Kind, LLVMContext &Ctx) {
+#if LLVM_VERSION_MAJOR >= 16
+  MemoryBufferRef BiFModuleBuffer = BC.getBiFModule(Kind);
+#else
   MemoryBufferRef BiFModuleBuffer =
       getAnalysis<GenXBackendConfig>().getBiFModule(Kind);
+#endif
   return vc::getLazyBiFModuleOrReportError(BiFModuleBuffer, Ctx);
 }

IGC/VectorCompiler/lib/PassPluginLibrary/CMakeLists.txt

@@ -25,6 +25,9 @@ add_llvm_library(
   $<TARGET_OBJECTS:VCGenXUtils>
   $<TARGET_OBJECTS:VCTransforms>
   $<TARGET_OBJECTS:VCGeneralUtils>
+  $<TARGET_OBJECTS:VCInternalIntrinsics>
+  $<TARGET_OBJECTS:${IGC_BUILD__PROJ__BiFManager}>
+  $<TARGET_OBJECTS:${IGC_BUILD__PROJ__BiFLib_OCL}>
   MODULE
   PLUGIN_TOOL opt
 )

IGC/VectorCompiler/lib/PassPluginLibrary/Plugin.cpp

@@ -10,6 +10,7 @@ SPDX-License-Identifier: MIT
 #include "llvm/Passes/PassPlugin.h"
 
 #include "vc/GenXOpts/GenXOptsNewPM.h"
+#include "vc/Support/BackendConfig.h"
 
 using namespace llvm;
 
@@ -18,6 +19,7 @@ void registerPluginPasses(PassBuilder &PB) {
 
   PB.registerAnalysisRegistrationCallback([=](ModuleAnalysisManager &MAM) {
     MAM.registerPass([&] { return CMABIAnalysisPass(); });
+    MAM.registerPass([&] { return GenXBackendConfigPass(); });
   });
 
 #define ADD_PASS(NAME, CREATE_PASS)                                            \
@@ -26,6 +28,15 @@ void registerPluginPasses(PassBuilder &PB) {
     return true;                                                               \
   }
 
+  PB.registerPipelineParsingCallback(
+      [=](StringRef Name, CGSCCPassManager &PM,
+          ArrayRef<PassBuilder::PipelineElement>) {
+#define CGSCC_PASS(NAME, CREATE_PASS) ADD_PASS(NAME, CREATE_PASS)
+#include "GenXPassRegistry.def"
+#undef CGSCC_PASS
+        return false;
+      });
+
   PB.registerPipelineParsingCallback(
       [=](StringRef Name, ModulePassManager &PM,
           ArrayRef<PassBuilder::PipelineElement>) {

IGC/VectorCompiler/lib/Support/BackendConfig.cpp

@@ -234,17 +234,30 @@ void GenXBackendData::setOwningBiFModuleIf(
     setOwningBiFModule(Kind, std::move(ModuleBuffer));
 }
 
-GenXBackendConfig::GenXBackendConfig()
-    : ImmutablePass(ID), Options{GenXBackendOptions::InitFromLLVMOpts{}},
-      Data{GenXBackendData::InitFromLLMVOpts{}} {
+GenXBackendConfig::GenXBackendConfig() : ImmutablePass(ID) {
   initializeGenXBackendConfigPass(*PassRegistry::getPassRegistry());
 }
 
 GenXBackendConfig::GenXBackendConfig(GenXBackendOptions &&OptionsIn,
                                      GenXBackendData &&DataIn)
-    : ImmutablePass(ID), Options(std::move(OptionsIn)),
-      Data(std::move(DataIn)) {
+    : ImmutablePass(ID),
+      GenXBackendConfigResult(std::move(OptionsIn), std::move(DataIn)) {
   initializeGenXBackendConfigPass(*PassRegistry::getPassRegistry());
 }
 
 INITIALIZE_PASS(GenXBackendConfig, DEBUG_TYPE, DEBUG_TYPE, false, true)
+
+#if LLVM_VERSION_MAJOR >= 16
+
+AnalysisKey GenXBackendConfigPass::Key;
+
+GenXBackendConfigPass::Result
+GenXBackendConfigPass::run(llvm::Module &M,
+                           llvm::AnalysisManager<llvm::Module> &AM) {
+
+  GenXBackendConfig BC;
+  BC.runOnModule(M);
+  return std::move(BC.getResult());
+}
+
+#endif

IGC/VectorCompiler/test/BTIAssignment/debug_shift.ll

@@ -8,10 +8,10 @@
 
 ; Check that bti assignment starts from 1 if debuggable kernels needed.
 
-; RUN: %opt_typed_ptrs %use_old_pass_manager% -GenXBTIAssignment -vc-reserve-bti-zero -march=genx64 -mcpu=Gen9 -S < %s | FileCheck %s --check-prefix=CHECK_RESERVE
-; RUN: %opt_opaque_ptrs %use_old_pass_manager% -GenXBTIAssignment -vc-reserve-bti-zero -march=genx64 -mcpu=Gen9 -S < %s | FileCheck %s --check-prefix=CHECK_RESERVE
-; RUN: %opt_typed_ptrs %use_old_pass_manager% -GenXBTIAssignment  -march=genx64 -mcpu=Gen9 -S < %s | FileCheck %s --check-prefix=CHECK_NO_RESERVE
-; RUN: %opt_opaque_ptrs %use_old_pass_manager% -GenXBTIAssignment  -march=genx64 -mcpu=Gen9 -S < %s | FileCheck %s --check-prefix=CHECK_NO_RESERVE
+; RUN: %opt_typed_ptrs %use_old_pass_manager% %pass_pref%GenXBTIAssignment -vc-reserve-bti-zero -march=genx64 -mcpu=Gen9 -S < %s | FileCheck %s --check-prefix=CHECK_RESERVE
+; RUN: %opt_opaque_ptrs %use_old_pass_manager% %pass_pref%GenXBTIAssignment -vc-reserve-bti-zero -march=genx64 -mcpu=Gen9 -S < %s | FileCheck %s --check-prefix=CHECK_RESERVE
+; RUN: %opt_typed_ptrs %use_old_pass_manager% %pass_pref%GenXBTIAssignment  -march=genx64 -mcpu=Gen9 -S < %s | FileCheck %s --check-prefix=CHECK_NO_RESERVE
+; RUN: %opt_opaque_ptrs %use_old_pass_manager% %pass_pref%GenXBTIAssignment  -march=genx64 -mcpu=Gen9 -S < %s | FileCheck %s --check-prefix=CHECK_NO_RESERVE
 
 target datalayout = "e-p:64:64-i64:64-n8:16:32:64"
 target triple = "spir64-unknown-unknown"