Llvm16

.github/workflows/ccpp.yml

@@ -16,7 +16,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        llvm: ["7", "8", "9", "10", "11", "12", "13", "14", "15"]
+        llvm: ["7", "8", "9", "10", "11", "12", "13", "14", "15", "16"]
         build: ["Release"] # "RelWithDebInfo"
         os: [ubuntu-20.04]
 

.github/workflows/enzyme-ci.yml

@@ -14,7 +14,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        llvm: ["7", "8", "9", "10", "11", "12", "13", "14", "15"]
+        llvm: ["7", "8", "9", "10", "11", "12", "13", "14", "15", "16"]
         build: ["Release", "Debug"] # "RelWithDebInfo"
         os: [ubuntu-20.04] #self-hosted]
 
@@ -67,7 +67,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        llvm: ["8", "9", "11", "12", "13", "14", "15"]
+        llvm: ["8", "9", "11", "12", "13", "14", "15", "16"]
         build: ["Release", "Debug"] # "RelWithDebInfo"
 
     timeout-minutes: 30 

enzyme/Enzyme/ActivityAnalysisPrinter.cpp

@@ -1,5 +1,4 @@
-//===- TypeAnalysisPrinter.cpp - Printer utility pass for Type Analysis
-//----===//
+// ActivityAnalysisPrinter.cpp - Printer utility pass for Activity Analysis =//
 //
 //                             Enzyme Project
 //
@@ -19,7 +18,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file contains a utility LLVM pass for printing derived Type Analysis
+// This file contains a utility LLVM pass for printing derived Activity Analysis
 // results of a given function.
 //
 //===----------------------------------------------------------------------===//
@@ -50,6 +49,7 @@
 #include "llvm/Support/CommandLine.h"
 
 #include "ActivityAnalysis.h"
+#include "ActivityAnalysisPrinter.h"
 #include "FunctionUtils.h"
 #include "TypeAnalysis/TypeAnalysis.h"
 #include "Utils.h"
@@ -74,117 +74,122 @@ static llvm::cl::opt<bool>
                   cl::Hidden, cl::desc("Whether the return is duplicated"));
 namespace {
 
-class ActivityAnalysisPrinter final : public FunctionPass {
-public:
-  static char ID;
-  ActivityAnalysisPrinter() : FunctionPass(ID) {}
-
-  void getAnalysisUsage(AnalysisUsage &AU) const override {
-    AU.addRequired<TargetLibraryInfoWrapperPass>();
-  }
-
-  bool runOnFunction(Function &F) override {
-    if (F.getName() != FunctionToAnalyze)
-      return /*changed*/ false;
-
-#if LLVM_VERSION_MAJOR >= 10
-    auto &TLI = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
-#else
-    auto &TLI = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
-#endif
-
-    FnTypeInfo type_args(&F);
-    for (auto &a : type_args.Function->args()) {
-      TypeTree dt;
-      if (a.getType()->isFPOrFPVectorTy()) {
-        dt = ConcreteType(a.getType()->getScalarType());
-      } else if (a.getType()->isPointerTy()) {
-        auto et = a.getType()->getPointerElementType();
-        if (et->isFPOrFPVectorTy()) {
-          dt = TypeTree(ConcreteType(et->getScalarType())).Only(-1, nullptr);
-        } else if (et->isPointerTy()) {
-          dt = TypeTree(ConcreteType(BaseType::Pointer)).Only(-1, nullptr);
-        }
-      } else if (a.getType()->isIntOrIntVectorTy()) {
-        dt = ConcreteType(BaseType::Integer);
-      }
-      type_args.Arguments.insert(
-          std::pair<Argument *, TypeTree>(&a, dt.Only(-1, nullptr)));
-      // TODO note that here we do NOT propagate constants in type info (and
-      // should consider whether we should)
-      type_args.KnownValues.insert(
-          std::pair<Argument *, std::set<int64_t>>(&a, {}));
-    }
+bool printActivityAnalysis(llvm::Function &F, TargetLibraryInfo &TLI) {
+  if (F.getName() != FunctionToAnalyze)
+    return /*changed*/ false;
 
+  FnTypeInfo type_args(&F);
+  for (auto &a : type_args.Function->args()) {
     TypeTree dt;
-    if (F.getReturnType()->isFPOrFPVectorTy()) {
-      dt = ConcreteType(F.getReturnType()->getScalarType());
-    } else if (F.getReturnType()->isPointerTy()) {
-      auto et = F.getReturnType()->getPointerElementType();
+    if (a.getType()->isFPOrFPVectorTy()) {
+      dt = ConcreteType(a.getType()->getScalarType());
+    } else if (a.getType()->isPointerTy()) {
+      auto et = a.getType()->getPointerElementType();
       if (et->isFPOrFPVectorTy()) {
         dt = TypeTree(ConcreteType(et->getScalarType())).Only(-1, nullptr);
       } else if (et->isPointerTy()) {
         dt = TypeTree(ConcreteType(BaseType::Pointer)).Only(-1, nullptr);
       }
-    } else if (F.getReturnType()->isIntOrIntVectorTy()) {
+    } else if (a.getType()->isIntOrIntVectorTy()) {
       dt = ConcreteType(BaseType::Integer);
     }
-    type_args.Return = dt.Only(-1, nullptr);
-
-    PreProcessCache PPC;
-    TypeAnalysis TA(PPC.FAM);
-    TypeResults TR = TA.analyzeFunction(type_args);
-
-    llvm::SmallPtrSet<llvm::Value *, 4> ConstantValues;
-    llvm::SmallPtrSet<llvm::Value *, 4> ActiveValues;
-    for (auto &a : type_args.Function->args()) {
-      if (InactiveArgs) {
-        ConstantValues.insert(&a);
-      } else if (a.getType()->isIntOrIntVectorTy()) {
-        ConstantValues.insert(&a);
-      } else {
-        ActiveValues.insert(&a);
-      }
+    type_args.Arguments.insert(
+        std::pair<Argument *, TypeTree>(&a, dt.Only(-1, nullptr)));
+    // TODO note that here we do NOT propagate constants in type info (and
+    // should consider whether we should)
+    type_args.KnownValues.insert(
+        std::pair<Argument *, std::set<int64_t>>(&a, {}));
+  }
+
+  TypeTree dt;
+  if (F.getReturnType()->isFPOrFPVectorTy()) {
+    dt = ConcreteType(F.getReturnType()->getScalarType());
+  } else if (F.getReturnType()->isPointerTy()) {
+    auto et = F.getReturnType()->getPointerElementType();
+    if (et->isFPOrFPVectorTy()) {
+      dt = TypeTree(ConcreteType(et->getScalarType())).Only(-1, nullptr);
+    } else if (et->isPointerTy()) {
+      dt = TypeTree(ConcreteType(BaseType::Pointer)).Only(-1, nullptr);
+    }
+  } else if (F.getReturnType()->isIntOrIntVectorTy()) {
+    dt = ConcreteType(BaseType::Integer);
+  }
+  type_args.Return = dt.Only(-1, nullptr);
+
+  PreProcessCache PPC;
+  TypeAnalysis TA(PPC.FAM);
+  TypeResults TR = TA.analyzeFunction(type_args);
+
+  llvm::SmallPtrSet<llvm::Value *, 4> ConstantValues;
+  llvm::SmallPtrSet<llvm::Value *, 4> ActiveValues;
+  for (auto &a : type_args.Function->args()) {
+    if (InactiveArgs) {
+      ConstantValues.insert(&a);
+    } else if (a.getType()->isIntOrIntVectorTy()) {
+      ConstantValues.insert(&a);
+    } else {
+      ActiveValues.insert(&a);
     }
+  }
 
-    DIFFE_TYPE ActiveReturns = F.getReturnType()->isFPOrFPVectorTy()
-                                   ? DIFFE_TYPE::OUT_DIFF
-                                   : DIFFE_TYPE::CONSTANT;
-    if (DuplicatedRet)
-      ActiveReturns = DIFFE_TYPE::DUP_ARG;
-    SmallPtrSet<BasicBlock *, 4> notForAnalysis(getGuaranteedUnreachable(&F));
-    ActivityAnalyzer ATA(PPC, PPC.FAM.getResult<AAManager>(F), notForAnalysis,
-                         TLI, ConstantValues, ActiveValues, ActiveReturns);
-
-    for (auto &a : F.args()) {
-      ATA.isConstantValue(TR, &a);
+  DIFFE_TYPE ActiveReturns = F.getReturnType()->isFPOrFPVectorTy()
+                                 ? DIFFE_TYPE::OUT_DIFF
+                                 : DIFFE_TYPE::CONSTANT;
+  if (DuplicatedRet)
+    ActiveReturns = DIFFE_TYPE::DUP_ARG;
+  SmallPtrSet<BasicBlock *, 4> notForAnalysis(getGuaranteedUnreachable(&F));
+  ActivityAnalyzer ATA(PPC, PPC.FAM.getResult<AAManager>(F), notForAnalysis,
+                       TLI, ConstantValues, ActiveValues, ActiveReturns);
+
+  for (auto &a : F.args()) {
+    ATA.isConstantValue(TR, &a);
+    llvm::errs().flush();
+  }
+  for (auto &BB : F) {
+    for (auto &I : BB) {
+      ATA.isConstantInstruction(TR, &I);
+      ATA.isConstantValue(TR, &I);
       llvm::errs().flush();
     }
-    for (auto &BB : F) {
-      for (auto &I : BB) {
-        ATA.isConstantInstruction(TR, &I);
-        ATA.isConstantValue(TR, &I);
-        llvm::errs().flush();
-      }
-    }
+  }
 
-    for (auto &a : F.args()) {
-      bool icv = ATA.isConstantValue(TR, &a);
+  for (auto &a : F.args()) {
+    bool icv = ATA.isConstantValue(TR, &a);
+    llvm::errs().flush();
+    llvm::outs() << a << ": icv:" << icv << "\n";
+    llvm::outs().flush();
+  }
+  for (auto &BB : F) {
+    llvm::outs() << BB.getName() << "\n";
+    for (auto &I : BB) {
+      bool ici = ATA.isConstantInstruction(TR, &I);
+      bool icv = ATA.isConstantValue(TR, &I);
       llvm::errs().flush();
-      llvm::outs() << a << ": icv:" << icv << "\n";
+      llvm::outs() << I << ": icv:" << icv << " ici:" << ici << "\n";
       llvm::outs().flush();
     }
-    for (auto &BB : F) {
-      llvm::outs() << BB.getName() << "\n";
-      for (auto &I : BB) {
-        bool ici = ATA.isConstantInstruction(TR, &I);
-        bool icv = ATA.isConstantValue(TR, &I);
-        llvm::errs().flush();
-        llvm::outs() << I << ": icv:" << icv << " ici:" << ici << "\n";
-        llvm::outs().flush();
-      }
-    }
-    return /*changed*/ false;
+  }
+  return /*changed*/ false;
+}
+
+class ActivityAnalysisPrinter final : public FunctionPass {
+public:
+  static char ID;
+  ActivityAnalysisPrinter() : FunctionPass(ID) {}
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.addRequired<TargetLibraryInfoWrapperPass>();
+  }
+
+  bool runOnFunction(Function &F) override {
+
+#if LLVM_VERSION_MAJOR >= 10
+    auto &TLI = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
+#else
+    auto &TLI = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
+#endif
+
+    return printActivityAnalysis(F, TLI);
   }
 };
 
@@ -194,3 +199,12 @@ char ActivityAnalysisPrinter::ID = 0;
 
 static RegisterPass<ActivityAnalysisPrinter>
     X("print-activity-analysis", "Print Activity Analysis Results");
+
+ActivityAnalysisPrinterNewPM::Result
+ActivityAnalysisPrinterNewPM::run(llvm::Function &F,
+                                  llvm::FunctionAnalysisManager &FAM) {
+  bool changed = false;
+  changed = printActivityAnalysis(F, FAM.getResult<TargetLibraryAnalysis>(F));
+  return changed ? PreservedAnalyses::none() : PreservedAnalyses::all();
+}
+llvm::AnalysisKey ActivityAnalysisPrinterNewPM::Key;

enzyme/Enzyme/ActivityAnalysisPrinter.h

@@ -0,0 +1,48 @@
+//=- ActivityAnalysisPrinter.h - Printer utility pass for Activity Analysis =//
+//
+//                             Enzyme Project
+//
+// Part of the Enzyme Project, under the Apache License v2.0 with LLVM
+// Exceptions. See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// If using this code in an academic setting, please cite the following:
+// @incollection{enzymeNeurips,
+// title = {Instead of Rewriting Foreign Code for Machine Learning,
+//          Automatically Synthesize Fast Gradients},
+// author = {Moses, William S. and Churavy, Valentin},
+// booktitle = {Advances in Neural Information Processing Systems 33},
+// year = {2020},
+// note = {To appear in},
+// }
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains a utility LLVM pass for printing derived Activity Analysis
+// results of a given function.
+//
+//===----------------------------------------------------------------------===//
+#include <llvm/Config/llvm-config.h>
+
+#include "llvm/IR/PassManager.h"
+#include "llvm/Passes/PassPlugin.h"
+
+namespace llvm {
+class FunctionPass;
+}
+
+class ActivityAnalysisPrinterNewPM final
+    : public llvm::AnalysisInfoMixin<ActivityAnalysisPrinterNewPM> {
+  friend struct llvm::AnalysisInfoMixin<ActivityAnalysisPrinterNewPM>;
+
+private:
+  static llvm::AnalysisKey Key;
+
+public:
+  using Result = llvm::PreservedAnalyses;
+  ActivityAnalysisPrinterNewPM() {}
+
+  Result run(llvm::Function &M, llvm::FunctionAnalysisManager &MAM);
+
+  static bool isRequired() { return true; }
+};