Make another wave of passes NewPM compatible

src/aotcompile.cpp

@@ -899,6 +899,15 @@ static void registerCallbacks(PassBuilder &PB) {
                 PM.addPass(PropagateJuliaAddrspacesPass());
                 return true;
             }
+            if (Name == "LowerExcHandlers") {
+                PM.addPass(LowerExcHandlers());
+                return true;
+            }
+            if (Name == "GCInvariantVerifier") {
+                // TODO: Parse option and allow users to set `Strong`
+                PM.addPass(GCInvariantVerifierPass());
+                return true;
+            }
             return false;
         });
 
@@ -925,6 +934,14 @@ static void registerCallbacks(PassBuilder &PB) {
                 PM.addPass(RemoveJuliaAddrspacesPass());
                 return true;
             }
+            if (Name == "MultiVersioning") {
+                PM.addPass(MultiVersioning());
+                return true;
+            }
+            if (Name == "LowerPTLS") {
+                PM.addPass(LowerPTLSPass());
+                return true;
+            }
             return false;
         });
 

src/llvm-gc-invariant-verifier.cpp

@@ -4,6 +4,7 @@
 // See the devdocs for a description of these invariants.
 
 #include "llvm-version.h"
+#include "passes.h"
 
 #include <llvm-c/Core.h>
 #include <llvm-c/Types.h>
@@ -33,11 +34,10 @@
 
 using namespace llvm;
 
-struct GCInvariantVerifier : public FunctionPass, public InstVisitor<GCInvariantVerifier> {
-    static char ID;
+struct GCInvariantVerifier : public InstVisitor<GCInvariantVerifier> {
     bool Broken = false;
     bool Strong;
-    GCInvariantVerifier(bool Strong = false) : FunctionPass(ID), Strong(Strong) {}
+    GCInvariantVerifier(bool Strong = false) : Strong(Strong) {}
 
 private:
     void Check(bool Cond, const char *message, Value *Val) {
@@ -48,12 +48,6 @@ struct GCInvariantVerifier : public FunctionPass, public InstVisitor<GCInvariant
     }
 
 public:
-    void getAnalysisUsage(AnalysisUsage &AU) const override {
-        FunctionPass::getAnalysisUsage(AU);
-        AU.setPreservesAll();
-    }
-
-    bool runOnFunction(Function &F) override;
     void visitAddrSpaceCastInst(AddrSpaceCastInst &I);
     void visitLoadInst(LoadInst &LI);
     void visitStoreInst(StoreInst &SI);
@@ -188,19 +182,41 @@ void GCInvariantVerifier::visitPtrToIntInst(PtrToIntInst &PII) {
           "Illegal inttoptr", &PII);
 }
 
-bool GCInvariantVerifier::runOnFunction(Function &F) {
-    visit(F);
-    if (Broken) {
+PreservedAnalyses GCInvariantVerifierPass::run(Function &F, FunctionAnalysisManager &AM) {
+    GCInvariantVerifier GIV(Strong);
+    GIV.visit(F);
+    if (GIV.Broken) {
         abort();
     }
-    return false;
+    return PreservedAnalyses::all();
 }
 
-char GCInvariantVerifier::ID = 0;
-static RegisterPass<GCInvariantVerifier> X("GCInvariantVerifier", "GC Invariant Verification Pass", false, false);
+struct GCInvariantVerifierLegacy : public FunctionPass {
+    static char ID;
+    bool Strong;
+    GCInvariantVerifierLegacy(bool Strong=false) : FunctionPass(ID), Strong(Strong) {}
+
+public:
+    void getAnalysisUsage(AnalysisUsage &AU) const override {
+        FunctionPass::getAnalysisUsage(AU);
+        AU.setPreservesAll();
+    }
+
+    bool runOnFunction(Function &F) override {
+        GCInvariantVerifier GIV(Strong);
+        GIV.visit(F);
+        if (GIV.Broken) {
+            abort();
+        }
+        return false;
+    }
+};
+
+char GCInvariantVerifierLegacy::ID = 0;
+static RegisterPass<GCInvariantVerifierLegacy> X("GCInvariantVerifier", "GC Invariant Verification Pass", false, false);
 
 Pass *createGCInvariantVerifierPass(bool Strong) {
-    return new GCInvariantVerifier(Strong);
+    return new GCInvariantVerifierLegacy(Strong);
 }
 
 extern "C" JL_DLLEXPORT void LLVMExtraAddGCInvariantVerifierPass_impl(LLVMPassManagerRef PM, LLVMBool Strong)

src/llvm-lower-handlers.cpp

@@ -1,6 +1,7 @@
 // This file is a part of Julia. License is MIT: https://julialang.org/license
 
 #include "llvm-version.h"
+#include "passes.h"
 
 #include <llvm-c/Core.h>
 #include <llvm-c/Types.h>
@@ -70,23 +71,8 @@ using namespace llvm;
  * handler structures to tell LLVM that it is free to re-use the stack slot
  * while the handler is not being used.
  */
-struct LowerExcHandlers : public FunctionPass {
-    static char ID;
-    LowerExcHandlers() : FunctionPass(ID)
-    {}
-
-private:
-    Function *except_enter_func;
-    Function *leave_func;
-    Function *jlenter_func;
-    Function *setjmp_func;
-    Function *lifetime_start;
-    Function *lifetime_end;
-
-    bool doInitialization(Module &M) override;
-    bool runOnFunction(Function &F) override;
-};
 
+namespace {
 /*
  * If the module doesn't have declarations for the jl_enter_handler and setjmp
  * functions, insert them.
@@ -115,24 +101,19 @@ static void ensure_enter_function(Module &M)
     }
 }
 
-bool LowerExcHandlers::doInitialization(Module &M) {
-    except_enter_func = M.getFunction("julia.except_enter");
+static bool lowerExcHandlers(Function &F) {
+    Module &M = *F.getParent();
+    Function *except_enter_func = M.getFunction("julia.except_enter");
     if (!except_enter_func)
-        return false;
+        return false; // No EH frames in this module
     ensure_enter_function(M);
-    leave_func = M.getFunction(XSTR(jl_pop_handler));
-    jlenter_func = M.getFunction(XSTR(jl_enter_handler));
-    setjmp_func = M.getFunction(jl_setjmp_name);
+    Function *leave_func = M.getFunction(XSTR(jl_pop_handler));
+    Function *jlenter_func = M.getFunction(XSTR(jl_enter_handler));
+    Function *setjmp_func = M.getFunction(jl_setjmp_name);
 
     auto T_pint8 = Type::getInt8PtrTy(M.getContext(), 0);
-    lifetime_start = Intrinsic::getDeclaration(&M, Intrinsic::lifetime_start, { T_pint8 });
-    lifetime_end = Intrinsic::getDeclaration(&M, Intrinsic::lifetime_end, { T_pint8 });
-    return true;
-}
-
-bool LowerExcHandlers::runOnFunction(Function &F) {
-    if (!except_enter_func)
-        return false; // No EH frames in this module
+    Function *lifetime_start = Intrinsic::getDeclaration(&M, Intrinsic::lifetime_start, { T_pint8 });
+    Function *lifetime_end = Intrinsic::getDeclaration(&M, Intrinsic::lifetime_end, { T_pint8 });
 
     /* Step 1: EH Depth Numbering */
     std::map<llvm::CallInst *, int> EnterDepth;
@@ -237,14 +218,32 @@ bool LowerExcHandlers::runOnFunction(Function &F) {
     return true;
 }
 
-char LowerExcHandlers::ID = 0;
-static RegisterPass<LowerExcHandlers> X("LowerExcHandlers", "Lower Julia Exception Handlers",
+} // anonymous namespace
+
+PreservedAnalyses LowerExcHandlers::run(Function &F, FunctionAnalysisManager &AM)
+{
+    lowerExcHandlers(F);
+    return PreservedAnalyses::all();
+}
+
+
+struct LowerExcHandlersLegacy : public FunctionPass {
+    static char ID;
+    LowerExcHandlersLegacy() : FunctionPass(ID)
+    {}
+    bool runOnFunction(Function &F) {
+        return lowerExcHandlers(F);
+    }
+};
+
+char LowerExcHandlersLegacy::ID = 0;
+static RegisterPass<LowerExcHandlersLegacy> X("LowerExcHandlers", "Lower Julia Exception Handlers",
                                          false /* Only looks at CFG */,
                                          false /* Analysis Pass */);
 
 Pass *createLowerExcHandlersPass()
 {
-    return new LowerExcHandlers();
+    return new LowerExcHandlersLegacy();
 }
 
 extern "C" JL_DLLEXPORT void LLVMExtraAddLowerExcHandlersPass_impl(LLVMPassManagerRef PM)