Convert control point pass to new pass manager.

The pass previously used the legacy pass manager, since that was default
in LLVM 12.

In LLVM 13 the new pass manager is default. This change converts the
control point pass from a legacy pass to a new pass.

Author: vext01

llvm/include/llvm/Transforms/Yk/ControlPoint.h

@@ -11,8 +11,11 @@
 #define YK_NEW_CONTROL_POINT "yk_new_control_point"
 
 namespace llvm {
-class ModulePass;
-ModulePass *createYkControlPointPass();
+class YkControlPointPass : public PassInfoMixin<YkControlPointPass> {
+public:
+  explicit YkControlPointPass();
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
 } // namespace llvm
 
 #endif

llvm/lib/CodeGen/CMakeLists.txt

@@ -216,7 +216,6 @@ add_llvm_component_library(LLVMCodeGen
   Support
   Target
   TransformUtils
-  YkControlPoint
   )
 
 add_subdirectory(SelectionDAG)

llvm/lib/LTO/CMakeLists.txt

@@ -35,4 +35,5 @@ add_llvm_component_library(LLVMLTO
   Support
   Target
   TransformUtils
+  YkControlPoint
 )

llvm/lib/LTO/LTOBackend.cpp

@@ -46,6 +46,7 @@
 #include "llvm/Transforms/Scalar/LoopPassManager.h"
 #include "llvm/Transforms/Utils/FunctionImportUtils.h"
 #include "llvm/Transforms/Utils/SplitModule.h"
+#include "llvm/Transforms/Yk/ControlPoint.h"
 
 using namespace llvm;
 using namespace lto;
@@ -74,6 +75,11 @@ static cl::opt<bool> ThinLTOAssumeMerged(
     cl::desc("Assume the input has already undergone ThinLTO function "
              "importing and the other pre-optimization pipeline changes."));
 
+static cl::opt<bool>
+YkPatchCtrlPoint("yk-patch-control-point",
+  cl::init(false), cl::NotHidden,
+  cl::desc("Patch yk_control_point()"));
+
 LLVM_ATTRIBUTE_NORETURN static void reportOpenError(StringRef Path, Twine Msg) {
   errs() << "failed to open " << Path << ": " << Msg << '\n';
   errs().flush();
@@ -300,6 +306,13 @@ static void runNewPMPasses(const Config &Conf, Module &Mod, TargetMachine *TM,
     MPM.addPass(PB.buildLTODefaultPipeline(OL, ExportSummary));
   }
 
+  // We add the yk control point pass late in the pipeline (after all
+  // optimisation and just before verification and codegen) so that no IR
+  // optimisation passes have a chance to change the interface to the control
+  // point. The JIT runtime relies on the signature not being changed.
+  if (YkPatchCtrlPoint)
+    MPM.addPass(YkControlPointPass());
+
   if (!Conf.DisableVerify)
     MPM.addPass(VerifierPass());
 

llvm/lib/Transforms/IPO/CMakeLists.txt

@@ -71,5 +71,4 @@ add_llvm_component_library(LLVMipo
   TransformUtils
   Vectorize
   Instrumentation
-  YkControlPoint
   )

llvm/lib/Transforms/IPO/PassManagerBuilder.cpp

@@ -51,7 +51,6 @@
 #include "llvm/Transforms/Vectorize/LoopVectorize.h"
 #include "llvm/Transforms/Vectorize/SLPVectorizer.h"
 #include "llvm/Transforms/Vectorize/VectorCombine.h"
-#include "llvm/Transforms/Yk/ControlPoint.h"
 
 using namespace llvm;
 
@@ -189,11 +188,6 @@ cl::opt<AttributorRunOption> AttributorRun(
                clEnumValN(AttributorRunOption::NONE, "none",
                           "disable attributor runs")));
 
-static cl::opt<bool>
-YkPatchCtrlPoint("yk-patch-control-point",
-  cl::init(false), cl::NotHidden,
-  cl::desc("Patch yk_control_point()"));
-
 extern cl::opt<bool> EnableKnowledgeRetention;
 } // namespace llvm
 
@@ -1246,13 +1240,6 @@ void PassManagerBuilder::populateLTOPassManager(legacy::PassManagerBase &PM) {
 
   PM.add(createAnnotationRemarksLegacyPass());
 
-  // We add the yk control point pass late in the pipeline (after all
-  // optimisation and just before verification and codegen) so that no IR
-  // optimisation passes have a chance to change the interface to the control
-  // point. The JIT runtime relies on the signature not being changed.
-  if (YkPatchCtrlPoint)
-    PM.add(createYkControlPointPass());
-
   if (VerifyOutput)
     PM.add(createVerifierPass());
 }

llvm/lib/Transforms/Yk/ControlPoint.cpp

@@ -169,14 +169,15 @@ void createControlPoint(Module &Mod, Function *F, std::vector<Value *> LiveVars,
       (GlobalVariable *)nullptr);
 
   // Create control point entry block. Checks if we are currently tracing.
-  Value *GVTracingVal = Builder.CreateLoad(GVTracing);
+  Value *GVTracingVal = Builder.CreateLoad(Type::getInt8Ty(Context), GVTracing);
   Value *IsTracing =
       Builder.CreateICmp(CmpInst::Predicate::ICMP_EQ, GVTracingVal, Int0);
   Builder.CreateCondBr(IsTracing, BBNotTracing, BBTracing);
 
   // Create block for "not tracing" case. Checks if we already compiled a trace.
   Builder.SetInsertPoint(BBNotTracing);
-  Value *GVCompiledTraceVal = Builder.CreateLoad(GVCompiledTrace);
+  Value *GVCompiledTraceVal =
+      Builder.CreateLoad(Type::getInt8PtrTy(Context), GVCompiledTrace);
   Value *HasTrace = Builder.CreateICmp(CmpInst::Predicate::ICMP_EQ,
                                        GVCompiledTraceVal, PtNull);
   Builder.CreateCondBr(HasTrace, BBHasNoTrace, BBHasTrace);
@@ -193,7 +194,8 @@ void createControlPoint(Module &Mod, Function *F, std::vector<Value *> LiveVars,
   // Create block that checks if we've reached the same location again so we
   // can execute a compiled trace.
   Builder.SetInsertPoint(BBHasTrace);
-  Value *ValStartLoc = Builder.CreateLoad(GVStartLoc);
+  Value *ValStartLoc =
+      Builder.CreateLoad(Type::getInt32Ty(Context), GVStartLoc);
   Value *ExecTraceCond = Builder.CreateICmp(CmpInst::Predicate::ICMP_EQ,
                                             ValStartLoc, F->getArg(0));
   Builder.CreateCondBr(ExecTraceCond, BBExecuteTrace, BBReturn);
@@ -216,7 +218,8 @@ void createControlPoint(Module &Mod, Function *F, std::vector<Value *> LiveVars,
 
   // Create block that decides when to stop tracing.
   Builder.SetInsertPoint(BBTracing);
-  Value *ValStartLoc2 = Builder.CreateLoad(GVStartLoc);
+  Value *ValStartLoc2 =
+      Builder.CreateLoad(Type::getInt32Ty(Context), GVStartLoc);
   Value *StopTracingCond = Builder.CreateICmp(CmpInst::Predicate::ICMP_EQ,
                                               ValStartLoc2, F->getArg(0));
   Builder.CreateCondBr(StopTracingCond, BBStopTracing, BBReturn);
@@ -264,102 +267,86 @@ std::vector<Value *> getLiveVars(DominatorTree &DT, CallInst *OldCtrlPoint) {
   return Vec;
 }
 
-namespace {
-struct YkControlPointPass : public ModulePass {
-  static char ID;
+YkControlPointPass::YkControlPointPass() {}
 
-  YkControlPointPass() : ModulePass(ID) {}
+PreservedAnalyses YkControlPointPass::run(Module &M,
+                                          ModuleAnalysisManager &AM) {
+  LLVMContext &Context = M.getContext();
 
-  StringRef getPassName() const override {
-    return "Control Point Patching Pass";
+  // Locate the "dummy" control point provided by the user.
+  CallInst *OldCtrlPointCall = findControlPointCall(M);
+  if (OldCtrlPointCall == nullptr) {
+    Context.emitError("ykllvm couldn't find the call to `yk_control_point()`");
+    return PreservedAnalyses::all();
   }
 
-  bool runOnModule(Module &M) override {
-    LLVMContext &Context = M.getContext();
-
-    // Locate the "dummy" control point provided by the user.
-    CallInst *OldCtrlPointCall = findControlPointCall(M);
-    if (OldCtrlPointCall == nullptr) {
-      Context.emitError(
-          "ykllvm couldn't find the call to `yk_control_point()`");
-      return false;
-    }
-
-    // Replace old control point call.
-    IRBuilder<> Builder(OldCtrlPointCall);
-
-    // Get function containing the control point.
-    Function *Caller = OldCtrlPointCall->getFunction();
-
-    // Find all live variables just before the call to the control point.
-    DominatorTree DT(*Caller);
-    std::vector<Value *> LiveVals = getLiveVars(DT, OldCtrlPointCall);
-    if (LiveVals.size() == 0) {
-      Context.emitError(
-          "The interpreter loop has no live variables!\n"
-          "ykllvm doesn't support this scenario, as such an interpreter would "
-          "make little sense.");
-      return false;
-    }
-
-    // Generate the YkCtrlPointVars struct. This struct is used to package up a
-    // copy of all LLVM variables that are live just before the call to the
-    // control point. These are passed in to the patched control point so that
-    // they can be used as inputs and outputs to JITted trace code. The control
-    // point returns a new YkCtrlPointVars whose members may have been mutated
-    // by JITted trace code (if a trace was executed).
-    std::vector<Type *> TypeParams;
-    for (Value *V : LiveVals) {
-      TypeParams.push_back(V->getType());
-    }
-    StructType *CtrlPointReturnTy =
-        StructType::create(TypeParams, "YkCtrlPointVars");
-
-    // Create the new control point.
-    FunctionType *FType = FunctionType::get(
-        CtrlPointReturnTy, {Type::getInt32Ty(Context), CtrlPointReturnTy},
-        false);
-    Function *NF = Function::Create(FType, GlobalVariable::ExternalLinkage,
-                                    YK_NEW_CONTROL_POINT, M);
-
-    // Instantiate the YkCtrlPointStruct to pass in to the control point.
-    Value *InputStruct = cast<Value>(Constant::getNullValue(CtrlPointReturnTy));
-    unsigned LvIdx = 0;
-    for (Value *LV : LiveVals) {
-      InputStruct = Builder.CreateInsertValue(InputStruct, LV, LvIdx);
-      assert(LvIdx != UINT_MAX);
-      LvIdx++;
-    }
+  // Replace old control point call.
+  IRBuilder<> Builder(OldCtrlPointCall);
+
+  // Get function containing the control point.
+  Function *Caller = OldCtrlPointCall->getFunction();
+
+  // Find all live variables just before the call to the control point.
+  DominatorTree DT(*Caller);
+  std::vector<Value *> LiveVals = getLiveVars(DT, OldCtrlPointCall);
+  if (LiveVals.size() == 0) {
+    Context.emitError(
+        "The interpreter loop has no live variables!\n"
+        "ykllvm doesn't support this scenario, as such an interpreter would "
+        "make little sense.");
+    return PreservedAnalyses::all();
+  }
 
-    // Insert call to the new control point.
-    CallInst *CtrlPointRet = Builder.CreateCall(
-        NF, {OldCtrlPointCall->getArgOperand(0), InputStruct});
-
-    // Once the control point returns we need to extract the (potentially
-    // mutated) values from the returned YkCtrlPointStruct and reassign them to
-    // their corresponding live variables. In LLVM IR we can do this by simply
-    // replacing all future references with the new values.
-    LvIdx = 0;
-    for (Value *LV : LiveVals) {
-      Value *New = Builder.CreateExtractValue(cast<Value>(CtrlPointRet), LvIdx);
-      LV->replaceUsesWithIf(
-          New, [&](Use &U) { return DT.dominates(CtrlPointRet, U); });
-      assert(LvIdx != UINT_MAX);
-      LvIdx++;
-    }
+  // Generate the YkCtrlPointVars struct. This struct is used to package up a
+  // copy of all LLVM variables that are live just before the call to the
+  // control point. These are passed in to the patched control point so that
+  // they can be used as inputs and outputs to JITted trace code. The control
+  // point returns a new YkCtrlPointVars whose members may have been mutated
+  // by JITted trace code (if a trace was executed).
+  std::vector<Type *> TypeParams;
+  for (Value *V : LiveVals) {
+    TypeParams.push_back(V->getType());
+  }
+  StructType *CtrlPointReturnTy =
+      StructType::create(TypeParams, "YkCtrlPointVars");
+
+  // Create the new control point.
+  FunctionType *FType = FunctionType::get(
+      CtrlPointReturnTy, {Type::getInt32Ty(Context), CtrlPointReturnTy}, false);
+  Function *NF = Function::Create(FType, GlobalVariable::ExternalLinkage,
+                                  YK_NEW_CONTROL_POINT, M);
+
+  // Instantiate the YkCtrlPointStruct to pass in to the control point.
+  Value *InputStruct = cast<Value>(Constant::getNullValue(CtrlPointReturnTy));
+  unsigned LvIdx = 0;
+  for (Value *LV : LiveVals) {
+    InputStruct = Builder.CreateInsertValue(InputStruct, LV, LvIdx);
+    assert(LvIdx != UINT_MAX);
+    LvIdx++;
+  }
 
-    // Replace the call to the dummy control point.
-    OldCtrlPointCall->eraseFromParent();
+  // Insert call to the new control point.
+  CallInst *CtrlPointRet =
+      Builder.CreateCall(NF, {OldCtrlPointCall->getArgOperand(0), InputStruct});
+
+  // Once the control point returns we need to extract the (potentially
+  // mutated) values from the returned YkCtrlPointStruct and reassign them to
+  // their corresponding live variables. In LLVM IR we can do this by simply
+  // replacing all future references with the new values.
+  LvIdx = 0;
+  for (Value *LV : LiveVals) {
+    Value *New = Builder.CreateExtractValue(cast<Value>(CtrlPointRet), LvIdx);
+    LV->replaceUsesWithIf(
+        New, [&](Use &U) { return DT.dominates(CtrlPointRet, U); });
+    assert(LvIdx != UINT_MAX);
+    LvIdx++;
+  }
 
-    // Generate new control point logic.
-    createControlPoint(M, NF, LiveVals, CtrlPointReturnTy);
+  // Replace the call to the dummy control point.
+  OldCtrlPointCall->eraseFromParent();
 
-    return true;
-  }
-};
-char YkControlPointPass::ID = 0;
-} // namespace
+  // Generate new control point logic.
+  createControlPoint(M, NF, LiveVals, CtrlPointReturnTy);
 
-namespace llvm {
-ModulePass *createYkControlPointPass() { return new YkControlPointPass(); }
-} // namespace llvm
+  return PreservedAnalyses::none();
+}

yk_format_new_files.sh

@@ -3,7 +3,7 @@
 # Format any new files that we have added in our fork.
 
 # The LLVM version tag we are forked from.
-FORKED_LLVM_VERSION=llvmorg-12.0.0
+FORKED_LLVM_VERSION=llvmorg-13.0.0
 
 git diff --name-only --diff-filter=A ${FORKED_LLVM_VERSION} \
     `git branch --show-current` | egrep '\.(cpp|h)$' | xargs clang-format -i