[BPF][NewPM] Port bpf-adjust-opt to NPM and add it to pipeline

[yonghong-song]

I hit a build failure with latest llvm-project repo (top commit e42021d5cc25 ("[Clang][-fvisibility-from-dllstorageclass] Set DSO Locality from final visibility")).

-bash-4.4$ ninja && ninja install
[90/129] Building CXX object lib/Targe...MBPFCodeGen.dir/BPFTargetMachine.cpp.o
FAILED: lib/Target/BPF/CMakeFiles/LLVMBPFCodeGen.dir/BPFTargetMachine.cpp.o
/opt/rh/devtoolset-8/root/bin/g++ -DGTEST_HAS_RTTI=0 -D_DEBUG -D_GNU_SOURCE -DSTDC_CONSTANT_MACROS -DSTDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Ilib/Target/BPF -I../lib/Target/BPF -Iinclude -I../include -fPIC -fvisibility-inlines-hidden -Werror=date-time -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wno-missing-field-initializers -pedantic -Wno-long-long -Wimplicit-fallthrough -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-noexcept-type -Wdelete-non-virtual-dtor -Wno-comment -fdiagnostics-color -ffunction-sections -fdata-sections -O2 -fvisibility=hidden -fno-exceptions -fno-rtti -UNDEBUG -std=c++14 -MD -MT lib/Target/BPF/CMakeFiles/LLVMBPFCodeGen.dir/BPFTargetMachine.cpp.o -MF lib/Target/BPF/CMakeFiles/LLVMBPFCodeGen.dir/BPFTargetMachine.cpp.o.d -o lib/Target/BPF/CMakeFiles/LLVMBPFCodeGen.dir/BPFTargetMachine.cpp.o -c ../lib/Target/BPF/BPFTargetMachine.cpp
../lib/Target/BPF/BPFTargetMachine.cpp: In member function ‘virtual void llvm::BPFTargetMachine::registerPassBuilderCallbacks(llvm::PassBuilder&, bool)’:
../lib/Target/BPF/BPFTargetMachine.cpp:139:6: error: ‘class llvm::PassBuilder’ has no member named ‘registerPipelineEarlyAfterCleanupEPCallback’; did you mean ‘registerPipelineStartEPCallback’?

PB.registerPipelineEarlyAfterCleanupEPCallback(
   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   registerPipelineStartEPCallback

[99/129] Building CXX object tools/cla...j.clangCodeGen.dir/CodeGenModule.cpp.o
ninja: build stopped: subcommand failed.
-bash-4.4$

[aeubanks]

This depends on https://reviews.llvm.org/D91804, which hasn't been submitted yet
Perhaps I should have waited for that one to go in before adding reviewers, sorry

[yonghong-song]

No problem. I will wait for that dependent patch getting merged and then will do the review.

[aeubanks]

rebase

[aeubanks]

In D91990#2412807, @yonghong-song wrote:

No problem. I will wait for that dependent patch getting merged and then will do the review.

Should be good to go now

[yonghong-song]

The change looks good to me. Thanks!

llvm/lib/Target/BPF/BPF.h

 };
 
 class BPFPreserveDITypePass : public PassInfoMixin<BPFPreserveDITypePass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 
   static bool isRequired() { return true; }
 };
+
+class BPFAdjustOptPass : public PassInfoMixin<BPFAdjustOptPass> {
+public:
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
 } // namespace llvm
 
 #endif

llvm/lib/Target/BPF/BPFAdjustOpt.cpp

 static cl::opt<bool> DisableBPFavoidSpeculation(
     "bpf-disable-avoid-speculation", cl::Hidden,
     cl::desc("BPF: Disable Avoiding Speculative Code Motion."),
     cl::init(false));
 
 namespace {
 
 class BPFAdjustOpt final : public ModulePass {
+public:
+  static char ID;
+
+  BPFAdjustOpt() : ModulePass(ID) {}
+  bool runOnModule(Module &M) override;
+};
+
+class BPFAdjustOptImpl {
   struct PassThroughInfo {
     Instruction *Input;
     Instruction *UsedInst;
     uint32_t OpIdx;
     PassThroughInfo(Instruction *I, Instruction *U, uint32_t Idx)
         : Input(I), UsedInst(U), OpIdx(Idx) {}
   };
 
 public:
-  static char ID;
-  Module *Mod;
+  BPFAdjustOptImpl(Module *M) : M(M) {}
 
-  BPFAdjustOpt() : ModulePass(ID) {}
-  bool runOnModule(Module &M) override;
+  bool run();
 
 private:
+  Module *M;
   SmallVector<PassThroughInfo, 16> PassThroughs;
 
   void adjustBasicBlock(BasicBlock &BB);
   bool serializeICMPCrossBB(BasicBlock &BB);
   void adjustInst(Instruction &I);
   bool serializeICMPInBB(Instruction &I);
   bool avoidSpeculation(Instruction &I);
   bool insertPassThrough();
 };
 
 } // End anonymous namespace
 
 char BPFAdjustOpt::ID = 0;
 INITIALIZE_PASS(BPFAdjustOpt, "bpf-adjust-opt", "BPF Adjust Optimization",
                 false, false)
 
 ModulePass *llvm::createBPFAdjustOpt() { return new BPFAdjustOpt(); }
 
-bool BPFAdjustOpt::runOnModule(Module &M) {
-  Mod = &M;
-  for (Function &F : M)
+bool BPFAdjustOpt::runOnModule(Module &M) { return BPFAdjustOptImpl(&M).run(); }
+
+bool BPFAdjustOptImpl::run() {
+  for (Function &F : *M)
     for (auto &BB : F) {
       adjustBasicBlock(BB);
       for (auto &I : BB)
         adjustInst(I);
     }
 
   return insertPassThrough();
 }
 
-bool BPFAdjustOpt::insertPassThrough() {
+bool BPFAdjustOptImpl::insertPassThrough() {
   for (auto &Info : PassThroughs) {
     auto *CI = BPFCoreSharedInfo::insertPassThrough(
-        Mod, Info.UsedInst->getParent(), Info.Input, Info.UsedInst);
+        M, Info.UsedInst->getParent(), Info.Input, Info.UsedInst);
     Info.UsedInst->setOperand(Info.OpIdx, CI);
   }
 
   return !PassThroughs.empty();
 }
 
 // To avoid combining conditionals in the same basic block by
 // instrcombine optimization.
-bool BPFAdjustOpt::serializeICMPInBB(Instruction &I) {
+bool BPFAdjustOptImpl::serializeICMPInBB(Instruction &I) {
   // For:
   //   comp1 = icmp <opcode> ...;
   //   comp2 = icmp <opcode> ...;
   //   ... or comp1 comp2 ...
   // changed to:
   //   comp1 = icmp <opcode> ...;
   //   comp2 = icmp <opcode> ...;
   //   new_comp1 = __builtin_bpf_passthrough(seq_num, comp1)
bool BPFAdjustOptImpl::serializeICMPInBB(Instruction &I) {
   // an "or" instruction.
   PassThroughInfo Info(Icmp1, &I, 0);
   PassThroughs.push_back(Info);
   return true;
 }
 
 // To avoid combining conditionals in the same basic block by
 // instrcombine optimization.
-bool BPFAdjustOpt::serializeICMPCrossBB(BasicBlock &BB) {
+bool BPFAdjustOptImpl::serializeICMPCrossBB(BasicBlock &BB) {
   // For:
   //   B1:
   //     comp1 = icmp <opcode> ...;
   //     if (comp1) goto B2 else B3;
   //   B2:
   //     comp2 = icmp <opcode> ...;
   //     if (comp2) goto B4 else B5;
   //   B4:
bool BPFAdjustOptImpl::serializeICMPCrossBB(BasicBlock &BB) {
   PassThroughInfo Info(Cond, BI, 0);
   PassThroughs.push_back(Info);
 
   return true;
 }
 
 // To avoid speculative hoisting certain computations out of
 // a basic block.
-bool BPFAdjustOpt::avoidSpeculation(Instruction &I) {
+bool BPFAdjustOptImpl::avoidSpeculation(Instruction &I) {
   if (auto *LdInst = dyn_cast<LoadInst>(&I)) {
     if (auto *GV = dyn_cast<GlobalVariable>(LdInst->getOperand(0))) {
       if (GV->hasAttribute(BPFCoreSharedInfo::AmaAttr) ||
           GV->hasAttribute(BPFCoreSharedInfo::TypeIdAttr))
         return false;
     }
   }
 
bool BPFAdjustOptImpl::avoidSpeculation(Instruction &I) {
 
   if (!isCandidate || Candidates.empty())
     return false;
 
   PassThroughs.insert(PassThroughs.end(), Candidates.begin(), Candidates.end());
   return true;
 }
 
-void BPFAdjustOpt::adjustBasicBlock(BasicBlock &BB) {
+void BPFAdjustOptImpl::adjustBasicBlock(BasicBlock &BB) {
   if (!DisableBPFserializeICMP && serializeICMPCrossBB(BB))
     return;
 }
 
-void BPFAdjustOpt::adjustInst(Instruction &I) {
+void BPFAdjustOptImpl::adjustInst(Instruction &I) {
   if (!DisableBPFserializeICMP && serializeICMPInBB(I))
     return;
   if (!DisableBPFavoidSpeculation && avoidSpeculation(I))
     return;
 }
+
+PreservedAnalyses BPFAdjustOptPass::run(Module &M, ModuleAnalysisManager &AM) {
+  return BPFAdjustOptImpl(&M).run() ? PreservedAnalyses::none()
+                                    : PreservedAnalyses::all();
+}

llvm/lib/Target/BPF/BPFTargetMachine.cpp

PB.registerPipelineStartEPCallback(
         FPM.addPass(BPFAbstractMemberAccessPass(this));
         FPM.addPass(BPFPreserveDITypePass());
         MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
       });
   PB.registerPeepholeEPCallback([=](FunctionPassManager &FPM,
                                     PassBuilder::OptimizationLevel Level) {
     FPM.addPass(SimplifyCFGPass(SimplifyCFGOptions().hoistCommonInsts(true)));
   });
+  PB.registerPipelineEarlySimplificationEPCallback(
+      [=](ModulePassManager &MPM, PassBuilder::OptimizationLevel) {
+        MPM.addPass(BPFAdjustOptPass());
+      });
 }
 
 void BPFPassConfig::addIRPasses() {
   addPass(createBPFCheckAndAdjustIR());
   TargetPassConfig::addIRPasses();
 }
 
 // Install an instruction selector pass using

llvm/test/CodeGen/BPF/adjust-opt-icmp1.ll

 ; RUN: opt -O2 -mtriple=bpf-pc-linux %s | llvm-dis > %t1
 ; RUN: llc %t1 -o - | FileCheck -check-prefixes=CHECK %s
+; RUN: opt -passes='default<O2>' -mtriple=bpf-pc-linux %s | llvm-dis > %t1
+; RUN: llc %t1 -o - | FileCheck -check-prefixes=CHECK %s
 ; RUN: opt -O2 -mtriple=bpf-pc-linux -bpf-disable-serialize-icmp %s | llvm-dis > %t1
 ; RUN: llc %t1 -o - | FileCheck -check-prefixes=CHECK-DISABLE %s
+; RUN: opt -passes='default<O2>' -mtriple=bpf-pc-linux -bpf-disable-serialize-icmp %s | llvm-dis > %t1
+; RUN: llc %t1 -o - | FileCheck -check-prefixes=CHECK-DISABLE %s
 ;
 ; Source:
 ;   int foo();
 ;   int bar(int);
 ;   int test() {
 ;     int ret = foo();
 ;     if (ret <= 0 || ret > 7)
 ;       return 0;