Update llvmlite to be compatible with llvm-17

ffi/build.py

@@ -167,8 +167,8 @@ def main_posix(kind, library_ext):
     else:
         (version, _) = out.split('.', 1)
         version = int(version)
-        if version == 15:
-            msg = ("Building with LLVM 15; note that LLVM 15 support is "
+        if version == 17:
+            msg = ("Building with LLVM 17; note that LLVM 17 support is "
                    "presently experimental")
             show_warning(msg)
         elif version != 14:

ffi/core.cpp

@@ -23,18 +23,12 @@ LLVMPY_DisposeString(const char *msg) { free(const_cast<char *>(msg)); }
 API_EXPORT(LLVMContextRef)
 LLVMPY_GetGlobalContext() {
     auto context = LLVMGetGlobalContext();
-#if LLVM_VERSION_MAJOR > 14
-    LLVMContextSetOpaquePointers(context, false);
-#endif
     return context;
 }
 
 API_EXPORT(LLVMContextRef)
 LLVMPY_ContextCreate() {
     LLVMContextRef context = LLVMContextCreate();
-#if LLVM_VERSION_MAJOR > 14
-    LLVMContextSetOpaquePointers(context, false);
-#endif
     return context;
 }
 

ffi/custom_passes.cpp

@@ -1,5 +1,5 @@
 
-#include "core.h"
+#include "ffi_types.h"
 
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Function.h"
@@ -26,10 +26,11 @@
 using namespace llvm;
 
 namespace llvm {
-void initializeRefNormalizePassPass(PassRegistry &Registry);
-void initializeRefPrunePassPass(PassRegistry &Registry);
+void initializeRefNormalizeLegacyPassPass(PassRegistry &Registry);
+void initializeRefPruneLegacyPassPass(PassRegistry &Registry);
 } // namespace llvm
 
+namespace {
 /**
  * Checks if a call instruction is an incref
  *
@@ -104,13 +105,9 @@ template <class Tstack> struct raiiStack {
  * A FunctionPass to reorder incref/decref instructions such that decrefs occur
  * logically after increfs. This is a pre-requisite pass to the pruner passes.
  */
-struct RefNormalizePass : public FunctionPass {
-    static char ID;
-    RefNormalizePass() : FunctionPass(ID) {
-        initializeRefNormalizePassPass(*PassRegistry::getPassRegistry());
-    }
+struct RefNormalize {
 
-    bool runOnFunction(Function &F) override {
+    bool runOnFunction(Function &F) {
         bool mutated = false;
         // For each basic block in F
         for (BasicBlock &bb : F) {
@@ -158,7 +155,16 @@ struct RefNormalizePass : public FunctionPass {
     }
 };
 
-struct RefPrunePass : public FunctionPass {
+typedef enum {
+    None = 0b0000,
+    PerBasicBlock = 0b0001,
+    Diamond = 0b0010,
+    Fanout = 0b0100,
+    FanoutRaise = 0b1000,
+    All = PerBasicBlock | Diamond | Fanout | FanoutRaise
+} Subpasses;
+
+struct RefPrune {
     static char ID;
     static size_t stats_per_bb;
     static size_t stats_diamond;
@@ -175,25 +181,21 @@ struct RefPrunePass : public FunctionPass {
     /**
      * Enum for setting which subpasses to run, there is no interdependence.
      */
-    enum Subpasses {
-        None = 0b0000,
-        PerBasicBlock = 0b0001,
-        Diamond = 0b0010,
-        Fanout = 0b0100,
-        FanoutRaise = 0b1000,
-        All = PerBasicBlock | Diamond | Fanout | FanoutRaise
-    } flags;
 
-    RefPrunePass(Subpasses flags = Subpasses::All, size_t subgraph_limit = -1)
-        : FunctionPass(ID), flags(flags), subgraph_limit(subgraph_limit) {
-        initializeRefPrunePassPass(*PassRegistry::getPassRegistry());
-    }
+    Subpasses flags;
+
+    DominatorTree &DT;
+    PostDominatorTree &PDT;
+
+    RefPrune(DominatorTree &DT, PostDominatorTree &PDT,
+             Subpasses flags = Subpasses::All, size_t subgraph_limit = -1)
+        : DT(DT), PDT(PDT), flags(flags), subgraph_limit(subgraph_limit) {}
 
     bool isSubpassEnabledFor(Subpasses expected) {
         return (flags & expected) == expected;
     }
 
-    bool runOnFunction(Function &F) override {
+    bool runOnFunction(Function &F) {
         // state for LLVM function pass mutated IR
         bool mutated = false;
 
@@ -361,12 +363,6 @@ struct RefPrunePass : public FunctionPass {
      */
     bool runDiamondPrune(Function &F) {
         bool mutated = false;
-        // gets the dominator tree
-        auto &domtree = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
-        // gets the post-dominator tree
-        auto &postdomtree =
-            getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();
-
         // Find all increfs and decrefs in the Function and store them in
         // incref_list and decref_list respectively.
         std::vector<CallInst *> incref_list, decref_list;
@@ -394,8 +390,8 @@ struct RefPrunePass : public FunctionPass {
                     continue;
 
                 // incref DOM decref && decref POSTDOM incref
-                if (domtree.dominates(incref, decref) &&
-                    postdomtree.dominates(decref, incref)) {
+                if (DT.dominates(incref, decref) &&
+                    PDT.dominates(decref, incref)) {
                     // check that the decref cannot be executed multiple times
                     SmallBBSet tail_nodes;
                     tail_nodes.insert(decref->getParent());
@@ -1028,14 +1024,6 @@ struct RefPrunePass : public FunctionPass {
         return NULL;
     }
 
-    /**
-     * getAnalysisUsage() LLVM plumbing for the pass
-     */
-    void getAnalysisUsage(AnalysisUsage &Info) const override {
-        Info.addRequired<DominatorTreeWrapperPass>();
-        Info.addRequired<PostDominatorTreeWrapperPass>();
-    }
-
     /**
      * Checks if the first argument to the supplied call_inst is NULL and
      * returns true if so, false otherwise.
@@ -1163,34 +1151,124 @@ struct RefPrunePass : public FunctionPass {
             }
         }
     }
-}; // end of struct RefPrunePass
+}; // end of struct RefPrune
+
+} // namespace
+
+class RefPrunePass : public PassInfoMixin<RefPrunePass> {
+
+  public:
+    Subpasses flags;
+    size_t subgraph_limit;
+    RefPrunePass(Subpasses flags = Subpasses::All, size_t subgraph_limit = -1)
+        : flags(flags), subgraph_limit(subgraph_limit) {}
+
+    PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) {
+        auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
+        auto &PDT = AM.getResult<PostDominatorTreeAnalysis>(F);
+        if (RefPrune(DT, PDT, flags, subgraph_limit).runOnFunction(F)) {
+            return PreservedAnalyses::none();
+        }
+
+        return PreservedAnalyses::all();
+    }
+};
+
+class RefNormalizePass : public PassInfoMixin<RefNormalizePass> {
 
-char RefNormalizePass::ID = 0;
-char RefPrunePass::ID = 0;
+  public:
+    RefNormalizePass() = default;
 
-size_t RefPrunePass::stats_per_bb = 0;
-size_t RefPrunePass::stats_diamond = 0;
-size_t RefPrunePass::stats_fanout = 0;
-size_t RefPrunePass::stats_fanout_raise = 0;
+    PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) {
+        RefNormalize().runOnFunction(F);
 
-INITIALIZE_PASS(RefNormalizePass, "nrtrefnormalizepass", "Normalize NRT refops",
-                false, false)
+        return PreservedAnalyses::all();
+    }
+};
 
-INITIALIZE_PASS_BEGIN(RefPrunePass, "nrtrefprunepass", "Prune NRT refops",
-                      false, false)
+PreservedAnalyses AAEvaluator::run(Function &F, FunctionAnalysisManager &AM) {
+
+    return PreservedAnalyses::all();
+}
+
+class RefNormalizeLegacyPass : public FunctionPass {
+  public:
+    static char ID;
+    RefNormalizeLegacyPass() : FunctionPass(ID) {
+        initializeRefNormalizeLegacyPassPass(*PassRegistry::getPassRegistry());
+    }
+
+    bool runOnFunction(Function &F) override {
+        return RefNormalize().runOnFunction(F);
+    };
+};
+
+class RefPruneLegacyPass : public FunctionPass {
+
+  public:
+    static char ID; // Pass identification, replacement for typeid
+    // The maximum number of nodes that the fanout pruners will look at.
+    size_t subgraph_limit;
+    Subpasses flags;
+    RefPruneLegacyPass(Subpasses flags = Subpasses::All,
+                       size_t subgraph_limit = -1)
+        : FunctionPass(ID), flags(flags), subgraph_limit(subgraph_limit) {
+        initializeRefPruneLegacyPassPass(*PassRegistry::getPassRegistry());
+    }
+
+    bool runOnFunction(Function &F) override {
+        auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
+
+        auto &PDT =
+            getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();
+
+        return RefPrune(DT, PDT, flags, subgraph_limit).runOnFunction(F);
+    };
+
+    /**
+     * getAnalysisUsage() LLVM plumbing for the pass
+     */
+    void getAnalysisUsage(AnalysisUsage &Info) const override {
+        Info.addRequired<DominatorTreeWrapperPass>();
+        Info.addRequired<PostDominatorTreeWrapperPass>();
+    }
+};
+
+char RefNormalizeLegacyPass::ID = 0;
+char RefPruneLegacyPass::ID = 0;
+
+size_t RefPrune::stats_per_bb = 0;
+size_t RefPrune::stats_diamond = 0;
+size_t RefPrune::stats_fanout = 0;
+size_t RefPrune::stats_fanout_raise = 0;
+
+INITIALIZE_PASS(RefNormalizeLegacyPass, "nrtRefNormalize",
+                "Normalize NRT refops", false, false)
+
+INITIALIZE_PASS_BEGIN(RefPruneLegacyPass, "nrtRefPruneLegacyPass",
+                      "Prune NRT refops", false, false)
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
 INITIALIZE_PASS_DEPENDENCY(PostDominatorTreeWrapperPass)
 
-INITIALIZE_PASS_END(RefPrunePass, "refprunepass", "Prune NRT refops", false,
-                    false)
+INITIALIZE_PASS_END(RefPruneLegacyPass, "RefPruneLegacyPass",
+                    "Prune NRT refops", false, false)
+
 extern "C" {
 
 API_EXPORT(void)
-LLVMPY_AddRefPrunePass(LLVMPassManagerRef PM, int subpasses,
-                       size_t subgraph_limit) {
-    unwrap(PM)->add(new RefNormalizePass());
+LLVMPY_AddLegacyRefPrunePass(LLVMPassManagerRef PM, int subpasses,
+                             size_t subgraph_limit) {
+    unwrap(PM)->add(new RefNormalizeLegacyPass());
     unwrap(PM)->add(
-        new RefPrunePass((RefPrunePass::Subpasses)subpasses, subgraph_limit));
+        new RefPruneLegacyPass((Subpasses)subpasses, subgraph_limit));
+}
+
+API_EXPORT(void)
+LLVMPY_AddRefPrunePass(LLVMModulePassManager MPM, int subpasses,
+                       size_t subgraph_limit) {
+    MPM->addPass(createModuleToFunctionPassAdaptor(RefNormalizePass()));
+    MPM->addPass(createModuleToFunctionPassAdaptor(
+        RefPrunePass((Subpasses)subpasses, subgraph_limit)));
 }
 
 /**
@@ -1207,24 +1285,24 @@ typedef struct PruneStats {
 API_EXPORT(void)
 LLVMPY_DumpRefPruneStats(PRUNESTATS *buf, bool do_print) {
     /* PRUNESTATS is updated with the statistics about what has been pruned from
-     * the RefPrunePass static state vars. This isn't threadsafe but neither is
+     * the RefPrune static state vars. This isn't threadsafe but neither is
      * the LLVM pass infrastructure so it's all done under a python thread lock.
      *
      * do_print if set will print the stats to stderr.
      */
     if (do_print) {
         errs() << "refprune stats "
-               << "per-BB " << RefPrunePass::stats_per_bb << " "
-               << "diamond " << RefPrunePass::stats_diamond << " "
-               << "fanout " << RefPrunePass::stats_fanout << " "
-               << "fanout+raise " << RefPrunePass::stats_fanout_raise << " "
+               << "per-BB " << RefPrune::stats_per_bb << " "
+               << "diamond " << RefPrune::stats_diamond << " "
+               << "fanout " << RefPrune::stats_fanout << " "
+               << "fanout+raise " << RefPrune::stats_fanout_raise << " "
                << "\n";
     };
 
-    buf->basicblock = RefPrunePass::stats_per_bb;
-    buf->diamond = RefPrunePass::stats_diamond;
-    buf->fanout = RefPrunePass::stats_fanout;
-    buf->fanout_raise = RefPrunePass::stats_fanout_raise;
+    buf->basicblock = RefPrune::stats_per_bb;
+    buf->diamond = RefPrune::stats_diamond;
+    buf->fanout = RefPrune::stats_fanout;
+    buf->fanout_raise = RefPrune::stats_fanout_raise;
 }
 
 } // extern "C"

ffi/initfini.cpp

@@ -1,32 +1,13 @@
 #include "llvm-c/Core.h"
-#include "llvm-c/Initialization.h"
 #include "llvm-c/Target.h"
 
 #include "core.h"
 #include "llvm/Config/llvm-config.h"
+#include "llvm/InitializePasses.h"
+#include "llvm/PassRegistry.h"
 
 extern "C" {
 
-#define INIT(F)                                                                \
-    API_EXPORT(void) LLVMPY_Initialize##F() {                                  \
-        LLVMInitialize##F(LLVMGetGlobalPassRegistry());                        \
-    }
-
-INIT(Core)
-INIT(TransformUtils)
-INIT(ScalarOpts)
-INIT(ObjCARCOpts)
-INIT(Vectorization)
-INIT(InstCombine)
-INIT(IPO)
-// INIT(Instrumentation)
-INIT(Analysis)
-INIT(IPA)
-INIT(CodeGen)
-INIT(Target)
-
-#undef INIT
-
 API_EXPORT(void)
 LLVMPY_Shutdown() { LLVMShutdown(); }