Integrate llvm-project@587d6fcbb685e3a57 (#20948)

Carrying revert:
-
iree-org/llvm-project@1485df6

Cherry-pick:
-
iree-org/llvm-project@1b7547d
(Mirror of llvm/llvm-project#142025)

The revision also pathes torch-mlir for getBackwardSlice changes:
iree-org/torch-mlir@05a9860

The changes in IREE are for
llvm/llvm-project@6a8dde0

Closes #20928

---------

Signed-off-by: hanhanW <hanhan0912@gmail.com>

Author: hanhanW

compiler/src/iree/compiler/Codegen/Common/GPU/DecomposeHorizontallyFusedGemms.cpp

@@ -45,7 +45,9 @@ static LogicalResult captureUsedOperationsAndBlockArguements(
   auto yieldOp = cast<linalg::YieldOp>(linalgOp.getBlock()->getTerminator());
   Value result = yieldOp.getOperand(resultNumber);
 
-  getBackwardSlice(result, &usedOperations, options);
+  [[maybe_unused]] LogicalResult ret =
+      getBackwardSlice(result, &usedOperations, options);
+  assert(ret.succeeded());
 
   // Get all block arguments used by the operations. If any of the arguments
   // used is a dpsInit argument other than resultNumber, return failure.

compiler/src/iree/compiler/Codegen/Common/GPU/GPUCombineValueBarriers.cpp

@@ -137,8 +137,12 @@ combineValueBarrierPair(RewriterBase &rewriter,
   bOptions.filter = sliceFilterBackward;
   SetVector<Operation *> backwardSliceA;
   SetVector<Operation *> backwardSliceB;
-  getBackwardSlice(barrierA, &backwardSliceA, bOptions);
-  getBackwardSlice(barrierB, &backwardSliceB, bOptions);
+  [[maybe_unused]] LogicalResult resultA =
+      getBackwardSlice(barrierA, &backwardSliceA, bOptions);
+  assert(resultA.succeeded());
+  [[maybe_unused]] LogicalResult resultB =
+      getBackwardSlice(barrierB, &backwardSliceB, bOptions);
+  assert(resultB.succeeded());
   backwardSliceA.insert(backwardSliceB.begin(), backwardSliceB.end());
   // If the first barrier is contained in the combined backward slice of both
   // barriers, the barriers form a chain and cannot be combined.

compiler/src/iree/compiler/Codegen/Common/GPU/GPUCreateFastSlowPath.cpp

@@ -84,7 +84,9 @@ static void applyFastSlowPathConversion(mlir::FunctionOpInterface funcOp) {
   SmallVector<Value> eqZeroCmpVals;
   for (OpFoldResult pad : llvm::concat<OpFoldResult>(lowPads, highPads)) {
     if (auto padValue = dyn_cast<Value>(pad)) {
-      getBackwardSlice(padValue, &padSizeOps, options);
+      [[maybe_unused]] LogicalResult result =
+          getBackwardSlice(padValue, &padSizeOps, options);
+      assert(result.succeeded());
       padSizeOps.insert(padValue.getDefiningOp());
     }
     if (!isZero(pad)) {

compiler/src/iree/compiler/Codegen/LLVMGPU/KernelConfig.cpp

@@ -604,7 +604,9 @@ checkDispatchForVectorDistribution(mlir::FunctionOpInterface entryPoint) {
   SetVector<Operation *> slice;
 
   for (Operation *op : storeOps) {
-    getBackwardSlice(op, &slice, sliceOptions);
+    [[maybe_unused]] LogicalResult result =
+        getBackwardSlice(op, &slice, sliceOptions);
+    assert(result.succeeded());
   }
 
   SetVector<linalg::LinalgOp> computeOps;
@@ -3177,7 +3179,9 @@ LogicalResult initGPULaunchConfig(FunctionOpInterface funcOp) {
       BackwardSliceOptions options;
       options.inclusive = true;
       SetVector<Operation *> slices;
-      getBackwardSlice(indices, &slices, options);
+      [[maybe_unused]] LogicalResult result =
+          getBackwardSlice(indices, &slices, options);
+      assert(result.succeeded());
       genericToSkip.insert(slices.begin(), slices.end());
     }
   }

compiler/src/iree/compiler/Codegen/LLVMGPU/ROCDLConfigureBufferInstructions.cpp

@@ -52,7 +52,9 @@ static bool isDefinitelyWorkgroupUniform(Value arg) {
   }
   // Note: this is a bit conservative, in that it will traverse all the
   // arguments to a util.assume.int that isn't the immediate parent of val.
-  mlir::getBackwardSlice(arg, &dependencies, opts);
+  [[maybe_unused]] LogicalResult result =
+      getBackwardSlice(arg, &dependencies, opts);
+  assert(result.succeeded());
   return llvm::all_of(dependencies, [&](Operation *op) {
     if (matchPattern(op, m_Constant()))
       return true;

compiler/src/iree/compiler/Codegen/Transforms/Transforms.cpp

@@ -63,7 +63,9 @@ static SliceAndDynamicDims cloneOffsetsSizesAndStridesImpl(
     return sliceFilter(op, nonIndexComputationOperands, baseOp);
   };
   SetVector<Operation *> slice;
-  getBackwardSlice(baseOp, &slice, options);
+  [[maybe_unused]] LogicalResult ret =
+      getBackwardSlice(baseOp, &slice, options);
+  assert(ret.succeeded());
   IRMapping bvm;
   for (auto origOp : slice) {
     builder.clone(*origOp, bvm);
@@ -364,7 +366,9 @@ LogicalResult lowerWorkgroupCountFromSliceOp(
   llvm::SetVector<Operation *> slice;
   for (auto ofr : workgroupCount) {
     if (auto val = dyn_cast<Value>(ofr)) {
-      mlir::getBackwardSlice(val, &slice, options);
+      [[maybe_unused]] LogicalResult result =
+          getBackwardSlice(val, &slice, options);
+      assert(result.succeeded());
     }
   }
   // Since there are more than one slices, sort the operations again.
@@ -1848,7 +1852,9 @@ struct HoistForallFromFor : public OpRewritePattern<scf::ForOp> {
           }
         }
         SetVector<Operation *> tmpBackwardSlice;
-        getBackwardSlice(operand, &tmpBackwardSlice, backwardOptions);
+        [[maybe_unused]] LogicalResult result =
+            getBackwardSlice(operand, &tmpBackwardSlice, backwardOptions);
+        assert(result.succeeded());
         slice.set_union(tmpBackwardSlice);
       }
     }

compiler/src/iree/compiler/Codegen/Utils/Utils.cpp

@@ -1604,7 +1604,9 @@ bool hasFusedLeadingOp(linalg::LinalgOp rootOp) {
   SetVector<Operation *> backwardSlice;
   for (OpOperand *operand : rootOp.getDpsInputOperands()) {
     SetVector<Operation *> tmpBackwardSlice;
-    getBackwardSlice(operand->get(), &tmpBackwardSlice, options);
+    [[maybe_unused]] LogicalResult result =
+        getBackwardSlice(operand->get(), &tmpBackwardSlice, options);
+    assert(result.succeeded());
     backwardSlice.set_union(tmpBackwardSlice);
   }
 

compiler/src/iree/compiler/Dialect/Flow/Conversion/TensorToFlow/Utils.cpp

@@ -61,7 +61,9 @@ static bool producedByValueExtract(OpFoldResult index) {
 
   // Get the backward slice of the index.
   SetVector<Operation *> backwardSlice;
-  getBackwardSlice(indexVal, &backwardSlice, options);
+  [[maybe_unused]] LogicalResult result =
+      getBackwardSlice(indexVal, &backwardSlice, options);
+  assert(result.succeeded());
   return hasExtract;
 }
 

compiler/src/iree/compiler/Dialect/Flow/Transforms/RegionOpUtils.cpp

@@ -187,7 +187,9 @@ static bool checkShapeIsDataDependant(Operation *op) {
     };
     llvm::SetVector<Operation *> slice;
     for (Value initOperand : linalgOp.getDpsInits()) {
-      mlir::getBackwardSlice(initOperand, &slice, options);
+      [[maybe_unused]] LogicalResult result =
+          getBackwardSlice(initOperand, &slice, options);
+      assert(result.succeeded());
     }
     return llvm::any_of(slice, llvm::IsaPred<tensor::ExtractOp>);
   }

compiler/src/iree/compiler/Dialect/LinalgExt/Utils/Utils.cpp

@@ -384,7 +384,9 @@ bool isGatherlikeOp(Operation *op) {
     }
     return currOp->getBlock() == genericOp.getBody();
   };
-  mlir::getBackwardSlice(yieldOp.getOperand(0), &sliceOps, options);
+  [[maybe_unused]] LogicalResult result =
+      getBackwardSlice(yieldOp.getOperand(0), &sliceOps, options);
+  assert(result.succeeded());
   return hasTensorExtract;
 }
 

compiler/src/iree/compiler/DispatchCreation/CollapseDimensions.cpp

@@ -629,7 +629,9 @@ hoistTensorReshapesOutOfDispatchRegion(
     return op->getParentOfType<IREE::Flow::DispatchRegionOp>();
   };
   SetVector<Operation *> slice;
-  getBackwardSlice(returnOp, &slice, sliceOptions);
+  [[maybe_unused]] LogicalResult ret =
+      getBackwardSlice(returnOp, &slice, sliceOptions);
+  assert(ret.succeeded());
 
   // 2. Get the leaf operations that are `tensor.collapse_shape` and
   // `tensor_expand_shape` ops.
@@ -889,7 +891,9 @@ collapseDimensionsForDispatch(IRRewriter &rewriter,
     return isEligibleForCollapse(op) && parentOp == regionOp;
   };
   SetVector<Operation *> slice;
-  getBackwardSlice(rootOp.value(), &slice, sliceOptions);
+  [[maybe_unused]] LogicalResult ret =
+      getBackwardSlice(rootOp.value(), &slice, sliceOptions);
+  assert(ret.succeeded());
 
   // Step 3. Populate each op's info with a maximally collapsable reassociation
   // indicies

compiler/src/iree/compiler/DispatchCreation/FormScalarDispatches.cpp

@@ -121,7 +121,9 @@ llvm::SetVector<Operation *> computeSliceToMoveIntoDispatch(
   };
   options.omitBlockArguments = true;
   llvm::SetVector<Operation *> slice;
-  getBackwardSlice(rootOp, &slice, options);
+  [[maybe_unused]] LogicalResult result =
+      getBackwardSlice(rootOp, &slice, options);
+  assert(result.succeeded());
   return slice;
 }
 

compiler/src/iree/compiler/DispatchCreation/FuseHorizontalContractions.cpp

@@ -240,7 +240,8 @@ static bool isHorizontalToGroup(Operation *op,
     return !dominanceInfo.properlyDominates(op, seedOp);
   };
   llvm::SetVector<Operation *> slice;
-  getBackwardSlice(op, &slice, options);
+  [[maybe_unused]] LogicalResult result = getBackwardSlice(op, &slice, options);
+  assert(result.succeeded());
   return !llvm::any_of(currGroup, [&](Operation *groupedOp) {
     return slice.contains(groupedOp);
   });

compiler/src/iree/compiler/DispatchCreation/FusionUtils.cpp

@@ -120,7 +120,9 @@ LogicalResult moveOperandDefs(RewriterBase &rewriter,
   llvm::SetVector<Operation *> slice;
   for (auto op : operations) {
     for (auto operand : op->getOperands()) {
-      getBackwardSlice(operand, &slice, options);
+      [[maybe_unused]] LogicalResult result =
+          getBackwardSlice(operand, &slice, options);
+      assert(result.succeeded());
     }
     auto regions = op->getRegions();
     if (regions.empty()) {
@@ -129,7 +131,9 @@ LogicalResult moveOperandDefs(RewriterBase &rewriter,
     llvm::SetVector<Value> capturedVals;
     mlir::getUsedValuesDefinedAbove(regions, capturedVals);
     for (auto value : capturedVals) {
-      getBackwardSlice(value, &slice, options);
+      [[maybe_unused]] LogicalResult result =
+          getBackwardSlice(value, &slice, options);
+      assert(result.succeeded());
     }
   }
 

compiler/src/iree/compiler/Preprocessing/Common/MakeSingleDispatchForFunction.cpp

@@ -64,7 +64,9 @@ void MakeSingleDispatchForFunctionPass::runOnOperation() {
   // Filter returns true for any dialect not allowed.
   firstSliceOptions.filter = [&](Operation *op) { return !whitelistedOps(op); };
   llvm::SetVector<Operation *> firstSlice;
-  mlir::getBackwardSlice(block.getTerminator(), &firstSlice, firstSliceOptions);
+  [[maybe_unused]] LogicalResult ret =
+      getBackwardSlice(block.getTerminator(), &firstSlice, firstSliceOptions);
+  assert(ret.succeeded());
 
   // 2. Do the second slice starting from the first slice to remove any ABI
   // related operations on the argument.
@@ -75,7 +77,8 @@ void MakeSingleDispatchForFunctionPass::runOnOperation() {
   llvm::SetVector<Operation *> secondSlice;
   for (Operation *op : firstSlice) {
     for (Value operand : op->getOperands()) {
-      mlir::getBackwardSlice(operand, &secondSlice, secondSliceOptions);
+      ret = getBackwardSlice(operand, &secondSlice, secondSliceOptions);
+      assert(ret.succeeded());
     }
   }
   if (secondSlice.empty()) {