LLVM integrate (#2802)

* LLVM integrate

* fix

* Modify commit matrix in enzyme-rust.yml

Updated the commit matrix to an empty array as a placeholder until Rust updates LLVM.

* fix

Author: wsmoses

.github/workflows/enzyme-mlir.yml

@@ -45,7 +45,7 @@ jobs:
     - uses: actions/checkout@v4
       with:
         repository: 'llvm/llvm-project'
-        ref: '293623ce99d4d6819378311c1506c5ab08d1d860'
+        ref: 'a7c97252ed18839e87796dffd3926086ab62e8fd'
         path: 'llvm-project'
 
     - name: Set BASE_DIR

enzyme/Enzyme/CacheUtility.cpp

@@ -264,10 +264,17 @@ void RemoveRedundantIVs(
     if (auto addrec = dyn_cast<SCEVAddRecExpr>(S)) {
       if (addrec->getLoop()->getHeader() == Header) {
         if (auto add_or_mul = dyn_cast<BinaryOperator>(NewIV)) {
+#if LLVM_VERSION_MAJOR >= 23
+          if (any(addrec->getNoWrapFlags(llvm::SCEV::FlagNUW)))
+            add_or_mul->setHasNoUnsignedWrap(true);
+          if (any(addrec->getNoWrapFlags(llvm::SCEV::FlagNSW)))
+            add_or_mul->setHasNoSignedWrap(true);
+#else
           if (addrec->getNoWrapFlags(llvm::SCEV::FlagNUW))
             add_or_mul->setHasNoUnsignedWrap(true);
           if (addrec->getNoWrapFlags(llvm::SCEV::FlagNSW))
             add_or_mul->setHasNoSignedWrap(true);
+#endif
         }
       }
     }

enzyme/Enzyme/Enzyme.cpp

@@ -3122,7 +3122,11 @@ AnalysisKey EnzymeNewPM::Key;
 #include "llvm/Transforms/Scalar/MergedLoadStoreMotion.h"
 
 static InlineParams getInlineParamsFromOptLevel(OptimizationLevel Level) {
+#if LLVM_VERSION_MAJOR >= 23
+  return getInlineParams(Level.getSpeedupLevel());
+#else
   return getInlineParams(Level.getSpeedupLevel(), Level.getSizeLevel());
+#endif
 }
 
 #include "llvm/Transforms/Scalar/LowerConstantIntrinsics.h"
@@ -3157,7 +3161,12 @@ void augmentPassBuilder(llvm::PassBuilder &PB) {
     bool LTOPreLink = false;
     // First rotate loops that may have been un-rotated by prior passes.
     // Disable header duplication at -Oz.
+#if LLVM_VERSION_MAJOR >= 23
+    LPM.addPass(LoopRotatePass(/*EnableLoopHeaderDuplication=*/true, LTOPreLink,
+                               /*CheckExitCount=*/true));
+#else
     LPM.addPass(LoopRotatePass(Level != OptimizationLevel::Oz, LTOPreLink));
+#endif
     // Some loops may have become dead by now. Try to delete them.
     // FIXME: see discussion in https://reviews.llvm.org/D112851,
     //        this may need to be revisited once we run GVN before
@@ -3267,7 +3276,9 @@ void augmentPassBuilder(llvm::PassBuilder &PB) {
       // This opens opportunities for globalopt (and inlining) by
       // substituting function pointers passed as arguments to direct uses
       // of functions.
-#if LLVM_VERSION_MAJOR >= 16
+#if LLVM_VERSION_MAJOR >= 23
+      MPM.addPass(IPSCCPPass(IPSCCPOptions(/*AllowFuncSpec=*/true)));
+#elif LLVM_VERSION_MAJOR >= 16
       MPM.addPass(IPSCCPPass(IPSCCPOptions(/*AllowFuncSpec=*/
                                            Level != OptimizationLevel::Os &&
                                            Level != OptimizationLevel::Oz)));

enzyme/Enzyme/MLIR/Implementations/ArithAutoDiffOpInterfaceImpl.cpp

@@ -53,7 +53,7 @@ struct ArithConstantOpBatchInterface
     }
     auto cop = mlir::Operation::create(
         src->getLoc(), src->getName(), resultTypes, {}, std::move(attrs),
-        OpaqueProperties(nullptr), mlir::BlockRange(), 0);
+        mlir::PropertyRef(), mlir::BlockRange(), 0);
     builder.insert(cop);
     mapper.map(src->getResult(0), cop->getResult(0));
     return success();

enzyme/Enzyme/MLIR/Implementations/CoreDialectsAutoDiffImplementations.cpp

@@ -119,10 +119,10 @@ void mlir::enzyme::detail::branchingForwardHandler(Operation *inst,
   }
 
   gutils->getNewFromOriginal(inst->getBlock())
-      ->push_back(
-          newInst->create(newInst->getLoc(), newInst->getName(), TypeRange(),
-                          newVals, attrs, OpaqueProperties(nullptr),
-                          newInst->getSuccessors(), newInst->getNumRegions()));
+      ->push_back(newInst->create(newInst->getLoc(), newInst->getName(),
+                                  TypeRange(), newVals, attrs,
+                                  mlir::PropertyRef(), newInst->getSuccessors(),
+                                  newInst->getNumRegions()));
   gutils->erase(newInst);
   return;
 }

enzyme/Enzyme/MLIR/Interfaces/CloneFunction.cpp

@@ -96,9 +96,9 @@ Operation *clone(Operation *src, IRMapping &mapper,
   if (!newOp) {
     SmallVector<Type> resultTypes(src->getResultTypes().begin(),
                                   src->getResultTypes().end());
-    newOp = Operation::create(
-        src->getLoc(), src->getName(), resultTypes, operands, src->getAttrs(),
-        OpaqueProperties(nullptr), successors, src->getNumRegions());
+    newOp = Operation::create(src->getLoc(), src->getName(), resultTypes,
+                              operands, src->getAttrs(), mlir::PropertyRef(),
+                              successors, src->getNumRegions());
 
     // Clone the regions.
     if (options.shouldCloneRegions()) {

enzyme/Enzyme/MLIR/Interfaces/EnzymeLogic.cpp

@@ -64,10 +64,10 @@ void createTerminator(MGradientUtils *gutils, mlir::Block *oBB,
     }
   }
 
-  nBB->push_back(
-      newInst->create(newInst->getLoc(), newInst->getName(), TypeRange(),
-                      retargs, newInst->getAttrs(), OpaqueProperties(nullptr),
-                      newInst->getSuccessors(), newInst->getNumRegions()));
+  nBB->push_back(newInst->create(newInst->getLoc(), newInst->getName(),
+                                 TypeRange(), retargs, newInst->getAttrs(),
+                                 mlir::PropertyRef(), newInst->getSuccessors(),
+                                 newInst->getNumRegions()));
   gutils->erase(newInst);
   return;
 }

enzyme/Enzyme/MLIR/Passes/EnzymeBatchPass.cpp

@@ -143,7 +143,7 @@ void batchCloneBlock(
 
     Operation *newOp = Operation::create(
         src.getLoc(), src.getName(), resultTypes, operands, src.getAttrs(),
-        OpaqueProperties(nullptr), successors, src.getNumRegions());
+        mlir::PropertyRef(), successors, src.getNumRegions());
 
     // Clone the regions.
     for (auto &&[oldReg, newReg] :

enzyme/Enzyme/MustExitScalarEvolution.cpp

@@ -625,9 +625,15 @@ static const SCEV *getPreStartForExtend(const SCEVAddRecExpr *AR, Type *Ty,
   //
 
   const SCEV *BECount = SE->getBackedgeTakenCount(L);
+#if LLVM_VERSION_MAJOR >= 23
+  if (PreAR && any(PreAR->getNoWrapFlags(WrapType)) &&
+      !isa<SCEVCouldNotCompute>(BECount) && SE->isKnownPositive(BECount))
+    return PreStart;
+#else
   if (PreAR && PreAR->getNoWrapFlags(WrapType) &&
       !isa<SCEVCouldNotCompute>(BECount) && SE->isKnownPositive(BECount))
     return PreStart;
+#endif
 
   // 2. Direct overflow check on the step operation's expression.
   unsigned BitWidth = SE->getTypeSizeInBits(AR->getType());
@@ -636,7 +642,12 @@ static const SCEV *getPreStartForExtend(const SCEVAddRecExpr *AR, Type *Ty,
       SE->getAddExpr((SE->*GetExtendExpr)(PreStart, WideTy, Depth),
                      (SE->*GetExtendExpr)(Step, WideTy, Depth));
   if ((SE->*GetExtendExpr)(Start, WideTy, Depth) == OperandExtendedStart) {
-    if (PreAR && AR->getNoWrapFlags(WrapType)) {
+#if LLVM_VERSION_MAJOR >= 23
+    if (PreAR && any(AR->getNoWrapFlags(WrapType)))
+#else
+    if (PreAR && AR->getNoWrapFlags(WrapType))
+#endif
+    {
       // If we know `AR` == {`PreStart`+`Step`,+,`Step`} is `WrapType` (FlagNSW
       // or FlagNUW) and that `PreStart` + `Step` is `WrapType` too, then
       // `PreAR` == {`PreStart`,+,`Step`} is also `WrapType`.  Cache this fact.
@@ -684,7 +695,7 @@ static SCEV::NoWrapFlags StrengthenNoWrapFlags(ScalarEvolution *SE,
   (void)CanAnalyze;
   assert(CanAnalyze && "don't call from other places!");
 
-  int SignOrUnsignMask = SCEV::FlagNUW | SCEV::FlagNSW;
+  auto SignOrUnsignMask = SCEV::FlagNUW | SCEV::FlagNSW;
   SCEV::NoWrapFlags SignOrUnsignWrap =
       ScalarEvolution::maskFlags(Flags, SignOrUnsignMask);
 
@@ -843,7 +854,13 @@ ScalarEvolution::ExitLimit MustExitScalarEvolution::howManyLessThans(
   // implicit/exceptional) which causes the loop to execute before the
   // exiting instruction we're analyzing would trigger UB.
   auto WrapType = IsSigned ? SCEV::FlagNSW : SCEV::FlagNUW;
+
+#if LLVM_VERSION_MAJOR >= 23
+  bool NoWrap = ControlsExit && any(IV->getNoWrapFlags(WrapType));
+#else
   bool NoWrap = ControlsExit && IV->getNoWrapFlags(WrapType);
+#endif
+
   ICmpInst::Predicate Cond = IsSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT;
 
   const SCEV *Stride = IV->getStepRecurrence(*this);